Panel Interface Board: inszt_adc.c Source File

 /*
 C TESTBED VERSION  : 9.7.2
 FILE UNDER TEST  : "C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\adc.c"
 DATE OF ANALYSIS : Thu Aug 27 13:17:31 2020
 */
 /**************************************************************************************/
 /**************************************************************************************/
 /**************************************************************************************/
 /**************************************************************************************/
 /* Section: Included Files */
 /**************************************************************************************/
 /**************************************************************************************/
 #define QQQdialect MPLABX
 #undef QQQ146
 #undef QQQ148
 #undef QQQbndchk
 #undef QQQ294
 #undef QQQEMBEDDEDICE
  /* Note: for BITMAP execution histories QQQthreaded is not defined */
 #undef QQQthreaded
 #undef QQQdo178b
 #undef QQQfixbra
 #define QQQswitch3
 #undef QQQternary
 #define QQQswitch
 #undef QQQmacrof
 #undef QQQMULTIPROCESSEXH
 #undef QQFLUSH
 #undef QQNEWBS
 #define qqqMaxBranchDepth     20
 #define QQQstructbitmap
  static int qqqqbmselwidth =           32 ;
  static int zzfileid =     63;
 #define QQQnumfil       23
 #undef QQQALGONE
 #undef QQQVCLFLG
 #undef QQQFORKFL
 #undef QQQIADDRF
 #undef QQQRTI
 #undef QQQPERFA
 #undef QQQADRMOD
 #undef QQQDCAPFL
 #undef QQQTEMPLATEONLY
 #define QQQNOATEXIT
 #define QQQUPLOADATEND
 #define QQQNOSTDIO
 #undef QQQASHLINGVITRA
 #define QQQBITMAP
  #define qqqbitmapint unsigned int
 #undef QQQBITMAPMCDC
 #undef QQQTIC2XSERIALIO
 #undef QQQTIC2XFLASH
 #undef QQQCOMPRESSED_EXH
 #undef QQQMAINFL
 #define QQQSINGLEFILE
 #define QQQFILEID
 #define QQQseparate
 extern int QQQindicator;
 static int QQQfirstmcdc=1;
 #define adc_63zzopen                                                                                          zzopen
  extern int adc_63zzopen                                                                                        ;
 #define adc_63zqqzqz1                                                                                         zqqzqz1
 #define QQQLDRA_PORT
 #ifndef QQQLDRA_PORT
 #define FILEPOINT FILE * f,
 #if !defined(QQQTEMPLATEONLY) && !defined(FILE) && !defined(QQQNOSTDIO)
 #include <stdio.h>
     /* ----------------------------------------------------------------------* 100 *
      * If stdio.h is not available then insert:
      *      typedef int * FILE;
      * -----------------------------------------------------------------------------
      */
 #endif  /* !(QQQTEMPLATEONLY) && !(FILE) && !(QQQNOSTDIO) */
 #else  /* QQQLDRA_PORT */
 #define FILEPOINT
 /*************************** LDRA_PORT *********************************/
 #ifdef QQQ_SHLAYOUT
 static int tbrun_mode=1;
 #else
 static int tbrun_mode=0;
 #endif /* QQQ_SHLAYOUT */
 #include "C:\LDRA_Toolsuite\Compiler_spec\Microchip\Mplabx_xc32_script\ldra_port.h"
 #include "C:\LDRA_Toolsuite\Compiler_spec\Microchip\Mplabx_xc32_script\ldra_port_common.h"
 #ifndef QQQ_SHLAYOUT
 #ifdef QQQMAINFL
 #include "C:\LDRA_Toolsuite\Compiler_spec\Microchip\Mplabx_xc32_script\ldra_port.c"
 #include "C:\LDRA_Toolsuite\Compiler_spec\Microchip\Mplabx_xc32_script\ldra_port_common.c"
 #endif /* QQQMAINFL */
 #endif /* QQQ_SHLAYOUT */
 /************************ END OF LDRA_PORT *****************************/
 #endif /* QQQLDRA_PORT */
 #ifndef QQQnumfil
 #define QQQnumfil 40  /* default setting */
 #endif  /* QQQnumfil */
 #if defined(QQQstructbitmap) && defined(QQQSINGLEFILE)
 #ifndef LDRA_VOID_FUNC
 #define LDRA_VOID_FUNC
   typedef void(*ldra_void_function)();
 #endif
 #if defined(QQQMAINFL)
   /* Set qqqshell_upload to 1 if you want to call the qqqtotalupload separately. Although
      through the target you would have to set this to 0 before calling the qqqupload.
      Move this into ldra_port mechanism. */
   int qqqshell_upload = 0;
   int QQQfcn_ptr_num = 0;
   static int qqqisinitialised = 0;
   ldra_void_function qqqaccumupload[QQQnumfil];
   ldra_void_function qqqaccumreset[QQQnumfil];
   void qqqtotalupload(void);
   void qqqtotalreset(void);
   void qqpopulate_array_fcn_ptrQQ(int x, ldra_void_function y, ldra_void_function z) {
     qqqaccumupload[x]=y;
     qqqaccumreset[x]=z;
     QQQfcn_ptr_num++;
   }
 #else  /* (QQQMAINFL) */
   extern int QQQfcn_ptr_num;
   extern ldra_void_function qqqaccumupload[QQQnumfil];
   extern void qqpopulate_array_fcn_ptrQQ(int x, ldra_void_function y, ldra_void_function z);
   static int qqqstructzzopen = 0;
 #endif  /* defined(QQQMAINFL) */
 #endif  /* defined(QQQstructbitmap) && defined(QQQSINGLEFILE) */
 #ifdef QQQ_KEEPCOMMENTS
   /* -----------------------------------------------------------------------* 101 *
   *            Special settings for systems lacking standard functions.
   * To include code for fprintf define ldra_fprintf
   * To include code for sscanf  define ldra_sscanf
   * -----------------------------------------------------------------------------
   */
 #endif  /* QQQ_KEEPCOMMENTS */
 #if !defined(QQQSUPPRESS_UNDEF)
 #undef ldra_fprintf
 #undef ldra_sscanf
 #endif  /* !defined(QQQSUPPRESS_UNDEF) */
   /*  #define ldra_fprintf */
   /*  #define ldra_sscanf */
 #undef QQQHITMAP_STORAGE
 #undef qqnull_params
 #define qqnull_params void
 #define QQQ_PROTOTYPE_DEF
   /* Conventional Instrumentation */
 #undef QQ_ANSI_PROTOTYPE
 #ifdef __STDC__
 #define QQ_ANSI_PROTOTYPE 1
 #else /* __STDC__ */
 #ifdef VAXC
 #define QQ_ANSI_PROTOTYPE 1
 #endif  /* VAXC */
 #endif  /* __STDC__ */
   static unsigned char qqqzzglobflag = 0;
   static struct bitmapstruct_t
   {
 #define ELEMENT(N) qqqbitmapint element##N;
 #define LASTELEMENT
 #include "adc_63zbelem.def"
 #undef ELEMENT
 #undef LASTELEMENT
   } bitmapstruct = {
 #define ELEMENT(N) 0,
 #undef LASTELEMENT
 #include "adc_63zbelem.def"
 #undef ELEMENT
   0};
   static void qqoutput(FILEPOINT char * s,int i);
   static void qqoutput2(FILEPOINT char * s,int i, int j);
   static void qqoutput3(FILEPOINT char * s,int i,int j,int k);
   static void qqoutput4(FILEPOINT char * s,int i,int j,int k,int l);
   static void qqoutput0(FILEPOINT char * s);
   static int adc_63zqqzqz(qqnull_params);
   static int adc_63zqqzqz1(qqnull_params);
   static int adc_63zqendz (int qqqi);
   static int adc_63zqzqzq (int qqqi);
   static void qqqupload(qqnull_params);
   static void qqqbitmapreset(qqnull_params);
 /* ------------------------------ END OF TESTBED PROTOTYPES -------------------------------- */
 /* OPEN FILE C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\adc.h */
 /**************************************************************************************/
 /**************************************************************************************/
 #ifndef ADC_H                                                                           /* Guard against multiple inclusion.*/
 #define ADC_H
 /**************************************************************************************/
 /**************************************************************************************/
 /* Section: Included Files */
 /**************************************************************************************/
 /**************************************************************************************/
 #include <stdint.h>
 #include <stdbool.h>
 /**************************************************************************************/
 /**************************************************************************************/
 /* Section: Data Types */
 /**************************************************************************************/
 /**************************************************************************************/
 /**************************************************************************************/
 /* ADC states
   Summary:
     ADC states enumeration
   Description:
     This enumeration defines the valid ADC states. These states
     determine the behavior of the ADC state machine at various times.
 */

 typedef
   enum
   {
     ADC_STATE_INIT = 0 ,
     ADC_STATE_WAIT ,
     ADC_STATE_WAIT_FOR_TIMER ,
     ADC_STATE_IDLE
   } ADC_STATES ;
 /**************************************************************************************/
 /* ADC_DATA
   Summary:
     Holds ADC_DATA used for the ADC tasks.
   Description:
     Holds ADC_DATA used for the ADC tasks. The state machine and variables
     used to control ADC functions are stored here.
   Remarks:
     None
  */

 typedef
   struct       /* This structure collects the variables and states required for these*/
   {
   /* functions to operate.*/
     ADC_STATES state ;
     uint16_t hvps_i ;
     uint16_t hvps_cont ;
     uint16_t wl_cps_i ;
     uint16_t wl_cps_v ;
     uint16_t wl_sps_i_cf ;
     uint16_t wl_sps_i ;
     bool tick ;
     bool ADCInt ;
   } ADC_DATA ;

 extern ADC_DATA
   ADC ;
 /**************************************************************************************/
 /**************************************************************************************/
 /* State Machine Functions */
 /**************************************************************************************/
 /**************************************************************************************/
 /*!*************************************************************************************
   Function:
     void ADC_Tasks(void)
   Summary:
     ADC tasks function
   Description:
     This routine is the ADC tasks function. It defines the ADC's state machine and
     core logic. This machine initializes the Timer and ADCs used to digitize signal
     inputs. Once the timer and ADCs are started, this machine is set to idle and the
     the updated ADC values are retrieved in the system interrupt routine.
   Precondition:
     The system ("SYS_Initialize") and application ("APP_Initialize")initialization
     should be called before calling this.
   Parameters:
     None.
   Returns:
     None.
   Example:
     ADC_Tasks()

   Remarks:
     This routine must be called from the APP_Tasks() routine.
  */

 void
   ADC_Tasks ( void ) ;
        /* ADC_H */
 /***************************************************************************************
  End of File
  */

 #endif /*00 C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\adc.h*/
 /*   CLOSE_FILE Include File */

 #include <stdbool.h>
 /* OPEN FILE C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\system_config\default\system_definitions.h */
 /*******************************************************************************
  System Definitions
  File Name:
  system_definitions.h
  Summary:
  MPLAB Harmony project system definitions.
  Description:
  This file contains the system-wide prototypes and definitions for an MPLAB
  Harmony project.
  *******************************************************************************/
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2013-2014 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
  *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _SYS_DEFINITIONS_H
 #define _SYS_DEFINITIONS_H
 // *****************************************************************************
 // *****************************************************************************
 // Section: Included Files
 // *****************************************************************************
 // *****************************************************************************
 #include <stdint.h>
 #include <stddef.h>
 #include <stdbool.h>
 #include "system/common/sys_common.h"
 #include "system/common/sys_module.h"
 /* OPEN FILE C:\microchip\harmony\v2_06\framework\driver\ic\drv_ic.h */
 /*******************************************************************************
  Input Capture Driver Interface Declarations for Static Single Instance Driver
  Company:
  Microchip Technology Inc.
  File Name:
  help_drv_ic.h
  Summary:
  Input Capture driver interface declarations for the static single instance
         driver.
  Description:
  The Input Capture device driver provides a simple interface to manage the
         Input Capture modules on Microchip microcontrollers. This file defines
         the interface declarations for the IC driver.

  Remarks:
  Static interfaces incorporate the driver instance number within the names
  of the routines, eliminating the need for an object ID or object handle.

  Static single-open interfaces also eliminate the need for the open handle.
 *******************************************************************************/
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2016 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
 *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _DRV_IC_H
 #define _DRV_IC_H
 /* OPEN FILE C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\system_config\default\system_config.h */
 /*******************************************************************************
  MPLAB Harmony System Configuration Header
  File Name:
  system_config.h
  Summary:
  Build-time configuration header for the system defined by this MPLAB Harmony
  project.
  Description:
  An MPLAB Project may have multiple configurations. This file defines the
  build-time options for a single configuration.
  Remarks:
  This configuration header must not define any prototypes or data
  definitions (or include any files that do). It only provides macro
  definitions for build-time configuration options that are not instantiated
  until used by another MPLAB Harmony module or application.
  Created with MPLAB Harmony Version 2.06
 *******************************************************************************/
 // DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2013-2015 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
 *******************************************************************************/
 // DOM-IGNORE-END
 #ifndef _SYSTEM_CONFIG_H
 #define _SYSTEM_CONFIG_H
 // *****************************************************************************
 // *****************************************************************************
 // Section: Included Files
 // *****************************************************************************
 // *****************************************************************************
 /* This section Includes other configuration headers necessary to completely
  define this configuration.
 */
 // DOM-IGNORE-BEGIN
 // DOM-IGNORE-END
 // *****************************************************************************
 // *****************************************************************************
 // Section: System Service Configuration
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Common System Service Configuration Options
 */
 #define SYS_VERSION_STR "2.06"
 #define SYS_VERSION 20600
 // *****************************************************************************
 /* Clock System Service Configuration Options
 */
 #define SYS_CLK_FREQ 200000000ul
 #define SYS_CLK_BUS_PERIPHERAL_1 100000000ul
 #define SYS_CLK_BUS_PERIPHERAL_2 100000000ul
 #define SYS_CLK_BUS_PERIPHERAL_3 100000000ul
 #define SYS_CLK_BUS_PERIPHERAL_4 100000000ul
 #define SYS_CLK_BUS_PERIPHERAL_5 100000000ul
 #define SYS_CLK_BUS_PERIPHERAL_7 200000000ul
 #define SYS_CLK_BUS_PERIPHERAL_8 100000000ul
 #define SYS_CLK_CONFIG_PRIMARY_XTAL 0ul
 #define SYS_CLK_CONFIG_SECONDARY_XTAL 32768ul
 /*** Ports System Service Configuration ***/
 #define SYS_PORT_A_ANSEL 0x3F00
 #define SYS_PORT_A_TRIS 0xFFED
 #define SYS_PORT_A_LAT 0x0010
 #define SYS_PORT_A_ODC 0x0000
 #define SYS_PORT_A_CNPU 0x0020
 #define SYS_PORT_A_CNPD 0x0000
 #define SYS_PORT_A_CNEN 0x0021
 #define SYS_PORT_B_ANSEL 0x10C8
 #define SYS_PORT_B_TRIS 0x91FF
 #define SYS_PORT_B_LAT 0x0000
 #define SYS_PORT_B_ODC 0x0000
 #define SYS_PORT_B_CNPU 0x0000
 #define SYS_PORT_B_CNPD 0x0000
 #define SYS_PORT_B_CNEN 0x0000
 #define SYS_PORT_C_ANSEL 0xCFE1
 #define SYS_PORT_C_TRIS 0xFFFF
 #define SYS_PORT_C_LAT 0x0000
 #define SYS_PORT_C_ODC 0x0000
 #define SYS_PORT_C_CNPU 0x0000
 #define SYS_PORT_C_CNPD 0x0000
 #define SYS_PORT_C_CNEN 0x0000
 #define SYS_PORT_D_ANSEL 0xC100
 #define SYS_PORT_D_TRIS 0xFFFF
 #define SYS_PORT_D_LAT 0x0000
 #define SYS_PORT_D_ODC 0x0000
 #define SYS_PORT_D_CNPU 0x0000
 #define SYS_PORT_D_CNPD 0x0000
 #define SYS_PORT_D_CNEN 0x0000
 #define SYS_PORT_E_ANSEL 0xFC00
 #define SYS_PORT_E_TRIS 0xFDFF
 #define SYS_PORT_E_LAT 0x0000
 #define SYS_PORT_E_ODC 0x0000
 #define SYS_PORT_E_CNPU 0x0000
 #define SYS_PORT_E_CNPD 0x0000
 #define SYS_PORT_E_CNEN 0x0000
 #define SYS_PORT_F_ANSEL 0xCEC0
 #define SYS_PORT_F_TRIS 0xEFFF
 #define SYS_PORT_F_LAT 0x0000
 #define SYS_PORT_F_ODC 0x0000
 #define SYS_PORT_F_CNPU 0x0000
 #define SYS_PORT_F_CNPD 0x0000
 #define SYS_PORT_F_CNEN 0x0000
 #define SYS_PORT_G_ANSEL 0x8CBC
 #define SYS_PORT_G_TRIS 0xDFFF
 #define SYS_PORT_G_LAT 0x0000
 #define SYS_PORT_G_ODC 0x0000
 #define SYS_PORT_G_CNPU 0x0000
 #define SYS_PORT_G_CNPD 0x0000
 #define SYS_PORT_G_CNEN 0x0000
 #define SYS_PORT_H_ANSEL 0x0070
 #define SYS_PORT_H_TRIS 0xB3FB
 #define SYS_PORT_H_LAT 0x0000
 #define SYS_PORT_H_ODC 0x0000
 #define SYS_PORT_H_CNPU 0x0000
 #define SYS_PORT_H_CNPD 0x0000
 #define SYS_PORT_H_CNEN 0x0000
 #define SYS_PORT_J_ANSEL 0x0000
 #define SYS_PORT_J_TRIS 0x8B7F
 #define SYS_PORT_J_LAT 0x0080
 #define SYS_PORT_J_ODC 0x0000
 #define SYS_PORT_J_CNPU 0x0000
 #define SYS_PORT_J_CNPD 0x0000
 #define SYS_PORT_J_CNEN 0x0800
 #define SYS_PORT_K_ANSEL 0xFF00
 #define SYS_PORT_K_TRIS 0xFFFF
 #define SYS_PORT_K_LAT 0x0000
 #define SYS_PORT_K_ODC 0x0000
 #define SYS_PORT_K_CNPU 0x0000
 #define SYS_PORT_K_CNPD 0x0000
 #define SYS_PORT_K_CNEN 0x0000
 /*** Interrupt System Service Configuration ***/
 #define SYS_INT true
 /*** Timer System Service Configuration ***/
 #define SYS_TMR_POWER_STATE SYS_MODULE_POWER_RUN_FULL
 #define SYS_TMR_DRIVER_INDEX DRV_TMR_INDEX_0
 #define SYS_TMR_MAX_CLIENT_OBJECTS 5
 #define SYS_TMR_FREQUENCY 1000
 #define SYS_TMR_FREQUENCY_TOLERANCE 10
 #define SYS_TMR_UNIT_RESOLUTION 10000
 #define SYS_TMR_CLIENT_TOLERANCE 10
 #define SYS_TMR_INTERRUPT_NOTIFICATION false
 // *****************************************************************************
 // *****************************************************************************
 // Section: Driver Configuration
 // *****************************************************************************
 // *****************************************************************************
 #define DRV_IC_DRIVER_MODE_STATIC
 #define USE_8BIT_PMP
 /*** SPI Driver Configuration ***/
 #define DRV_SPI_NUMBER_OF_MODULES 6
 /*** Driver Compilation and static configuration options. ***/
 /*** Select SPI compilation units.***/
 #define DRV_SPI_POLLED 1
 #define DRV_SPI_ISR 0
 #define DRV_SPI_MASTER 1
 #define DRV_SPI_SLAVE 0
 #define DRV_SPI_RM 0
 #define DRV_SPI_EBM 1
 #define DRV_SPI_8BIT 1
 #define DRV_SPI_16BIT 1
 #define DRV_SPI_32BIT 0
 #define DRV_SPI_DMA 0
 /*** SPI Driver Static Allocation Options ***/
 #define DRV_SPI_INSTANCES_NUMBER 3
 #define DRV_SPI_CLIENTS_NUMBER 3
 #define DRV_SPI_ELEMENTS_PER_QUEUE 10
 /* SPI Driver Instance 0 Configuration */
 #define DRV_SPI_SPI_ID_IDX0 SPI_ID_1
 #define DRV_SPI_TASK_MODE_IDX0 DRV_SPI_TASK_MODE_POLLED
 #define DRV_SPI_SPI_MODE_IDX0 DRV_SPI_MODE_MASTER
 #define DRV_SPI_ALLOW_IDLE_RUN_IDX0 false
 #define DRV_SPI_SPI_PROTOCOL_TYPE_IDX0 DRV_SPI_PROTOCOL_TYPE_FRAMED
 #define DRV_SPI_FRAME_SYNC_PULSE_IDX0 SPI_FRAME_SYNC_PULSE_ON_EVERY_DATA_CHARACTER
 #define DRV_SPI_FRAME_PULSE_POLARITY_IDX0 SPI_FRAME_PULSE_POLARITY_ACTIVE_LOW
 #define DRV_SPI_FRAME_PULSE_DIRECTION_IDX0 SPI_FRAME_PULSE_DIRECTION_OUTPUT
 #define DRV_SPI_FRAME_PULSE_EDGE_IDX0 SPI_FRAME_PULSE_EDGE_COINCIDES_FIRST_BIT_CLOCK
 #define DRV_SPI_FRAME_PULSE_WIDTH_IDX0 SPI_FRAME_PULSE_WIDTH_ONE_WORD_LENGTH
 #define DRV_SPI_COMM_WIDTH_IDX0 SPI_COMMUNICATION_WIDTH_16BITS
 #define DRV_SPI_CLOCK_SOURCE_IDX0 SPI_BAUD_RATE_PBCLK_CLOCK
 #define DRV_SPI_SPI_CLOCK_IDX0 CLK_BUS_PERIPHERAL_2
 #define DRV_SPI_BAUD_RATE_IDX0 1000000
 #define DRV_SPI_BUFFER_TYPE_IDX0 DRV_SPI_BUFFER_TYPE_ENHANCED
 #define DRV_SPI_CLOCK_MODE_IDX0 DRV_SPI_CLOCK_MODE_IDLE_LOW_EDGE_FALL
 #define DRV_SPI_INPUT_PHASE_IDX0 SPI_INPUT_SAMPLING_PHASE_IN_MIDDLE
 #define DRV_SPI_TRANSMIT_DUMMY_BYTE_VALUE_IDX0 0xFFFF
 #define DRV_SPI_QUEUE_SIZE_IDX0 10
 #define DRV_SPI_RESERVED_JOB_IDX0 1
 /* SPI Driver Instance 1 Configuration */
 #define DRV_SPI_SPI_ID_IDX1 SPI_ID_2
 #define DRV_SPI_TASK_MODE_IDX1 DRV_SPI_TASK_MODE_POLLED
 #define DRV_SPI_SPI_MODE_IDX1 DRV_SPI_MODE_MASTER
 #define DRV_SPI_ALLOW_IDLE_RUN_IDX1 false
 #define DRV_SPI_SPI_PROTOCOL_TYPE_IDX1 DRV_SPI_PROTOCOL_TYPE_FRAMED
 #define DRV_SPI_FRAME_SYNC_PULSE_IDX1 SPI_FRAME_SYNC_PULSE_ON_EVERY_DATA_CHARACTER
 #define DRV_SPI_FRAME_PULSE_POLARITY_IDX1 SPI_FRAME_PULSE_POLARITY_ACTIVE_LOW
 #define DRV_SPI_FRAME_PULSE_DIRECTION_IDX1 SPI_FRAME_PULSE_DIRECTION_OUTPUT
 #define DRV_SPI_FRAME_PULSE_EDGE_IDX1 SPI_FRAME_PULSE_EDGE_COINCIDES_FIRST_BIT_CLOCK
 #define DRV_SPI_FRAME_PULSE_WIDTH_IDX1 SPI_FRAME_PULSE_WIDTH_ONE_WORD_LENGTH
 #define DRV_SPI_COMM_WIDTH_IDX1 SPI_COMMUNICATION_WIDTH_8BITS
 #define DRV_SPI_CLOCK_SOURCE_IDX1 SPI_BAUD_RATE_PBCLK_CLOCK
 #define DRV_SPI_SPI_CLOCK_IDX1 CLK_BUS_PERIPHERAL_2
 #define DRV_SPI_BAUD_RATE_IDX1 1000000
 #define DRV_SPI_BUFFER_TYPE_IDX1 DRV_SPI_BUFFER_TYPE_ENHANCED
 #define DRV_SPI_CLOCK_MODE_IDX1 DRV_SPI_CLOCK_MODE_IDLE_LOW_EDGE_FALL
 #define DRV_SPI_INPUT_PHASE_IDX1 SPI_INPUT_SAMPLING_PHASE_IN_MIDDLE
 #define DRV_SPI_TRANSMIT_DUMMY_BYTE_VALUE_IDX1 0xFF
 #define DRV_SPI_QUEUE_SIZE_IDX1 10
 #define DRV_SPI_RESERVED_JOB_IDX1 1
 /* SPI Driver Instance 2 Configuration */
 #define DRV_SPI_SPI_ID_IDX2 SPI_ID_4
 #define DRV_SPI_TASK_MODE_IDX2 DRV_SPI_TASK_MODE_POLLED
 #define DRV_SPI_SPI_MODE_IDX2 DRV_SPI_MODE_MASTER
 #define DRV_SPI_ALLOW_IDLE_RUN_IDX2 false
 #define DRV_SPI_SPI_PROTOCOL_TYPE_IDX2 DRV_SPI_PROTOCOL_TYPE_FRAMED
 #define DRV_SPI_FRAME_SYNC_PULSE_IDX2 SPI_FRAME_SYNC_PULSE_ON_EVERY_DATA_CHARACTER
 #define DRV_SPI_FRAME_PULSE_POLARITY_IDX2 SPI_FRAME_PULSE_POLARITY_ACTIVE_LOW
 #define DRV_SPI_FRAME_PULSE_DIRECTION_IDX2 SPI_FRAME_PULSE_DIRECTION_OUTPUT
 #define DRV_SPI_FRAME_PULSE_EDGE_IDX2 SPI_FRAME_PULSE_EDGE_COINCIDES_FIRST_BIT_CLOCK
 #define DRV_SPI_FRAME_PULSE_WIDTH_IDX2 SPI_FRAME_PULSE_WIDTH_ONE_WORD_LENGTH
 #define DRV_SPI_COMM_WIDTH_IDX2 SPI_COMMUNICATION_WIDTH_16BITS
 #define DRV_SPI_CLOCK_SOURCE_IDX2 SPI_BAUD_RATE_PBCLK_CLOCK
 #define DRV_SPI_SPI_CLOCK_IDX2 CLK_BUS_PERIPHERAL_2
 #define DRV_SPI_BAUD_RATE_IDX2 500000
 #define DRV_SPI_BUFFER_TYPE_IDX2 DRV_SPI_BUFFER_TYPE_ENHANCED
 #define DRV_SPI_CLOCK_MODE_IDX2 DRV_SPI_CLOCK_MODE_IDLE_LOW_EDGE_FALL
 #define DRV_SPI_INPUT_PHASE_IDX2 SPI_INPUT_SAMPLING_PHASE_AT_END
 #define DRV_SPI_TRANSMIT_DUMMY_BYTE_VALUE_IDX2 0x0000
 #define DRV_SPI_QUEUE_SIZE_IDX2 10
 #define DRV_SPI_RESERVED_JOB_IDX2 1
 /*** Timer Driver Configuration ***/
 #define DRV_TMR_INTERRUPT_MODE true
 /*** Timer Driver 0 Configuration ***/
 #define DRV_TMR_PERIPHERAL_ID_IDX0 TMR_ID_2
 #define DRV_TMR_INTERRUPT_SOURCE_IDX0 INT_SOURCE_TIMER_2
 #define DRV_TMR_INTERRUPT_VECTOR_IDX0 INT_VECTOR_T2
 #define DRV_TMR_ISR_VECTOR_IDX0 _TIMER_2_VECTOR
 #define DRV_TMR_INTERRUPT_PRIORITY_IDX0 INT_PRIORITY_LEVEL4
 #define DRV_TMR_INTERRUPT_SUB_PRIORITY_IDX0 INT_SUBPRIORITY_LEVEL0
 #define DRV_TMR_CLOCK_SOURCE_IDX0 DRV_TMR_CLKSOURCE_INTERNAL
 #define DRV_TMR_PRESCALE_IDX0 TMR_PRESCALE_VALUE_8
 #define DRV_TMR_OPERATION_MODE_IDX0 DRV_TMR_OPERATION_MODE_16_BIT
 #define DRV_TMR_ASYNC_WRITE_ENABLE_IDX0 false
 #define DRV_TMR_POWER_STATE_IDX0
 #define DRV_TMR_PERIPHERAL_ID_IDX1 TMR_ID_7
 #define DRV_TMR_INTERRUPT_SOURCE_IDX1 INT_SOURCE_TIMER_7
 #define DRV_TMR_INTERRUPT_VECTOR_IDX1 INT_VECTOR_T7
 #define DRV_TMR_ISR_VECTOR_IDX1 _TIMER_7_VECTOR
 #define DRV_TMR_INTERRUPT_PRIORITY_IDX1 INT_PRIORITY_LEVEL3
 #define DRV_TMR_INTERRUPT_SUB_PRIORITY_IDX1 INT_SUBPRIORITY_LEVEL0
 #define DRV_TMR_CLOCK_SOURCE_IDX1 DRV_TMR_CLKSOURCE_INTERNAL
 #define DRV_TMR_PRESCALE_IDX1 TMR_PRESCALE_VALUE_16
 #define DRV_TMR_OPERATION_MODE_IDX1 DRV_TMR_OPERATION_MODE_16_BIT
 #define DRV_TMR_ASYNC_WRITE_ENABLE_IDX1 false
 #define DRV_TMR_POWER_STATE_IDX1
 /*** Timer Driver 2 Configuration ***/
 #define DRV_TMR_PERIPHERAL_ID_IDX2 TMR_ID_6
 #define DRV_TMR_INTERRUPT_SOURCE_IDX2 INT_SOURCE_TIMER_6
 #define DRV_TMR_INTERRUPT_VECTOR_IDX2 INT_VECTOR_T6
 #define DRV_TMR_ISR_VECTOR_IDX2 _TIMER_6_VECTOR
 #define DRV_TMR_INTERRUPT_PRIORITY_IDX2 INT_PRIORITY_LEVEL1
 #define DRV_TMR_INTERRUPT_SUB_PRIORITY_IDX2 INT_SUBPRIORITY_LEVEL0
 #define DRV_TMR_CLOCK_SOURCE_IDX2 DRV_TMR_CLKSOURCE_INTERNAL
 #define DRV_TMR_PRESCALE_IDX2 TMR_PRESCALE_VALUE_16
 #define DRV_TMR_OPERATION_MODE_IDX2 DRV_TMR_OPERATION_MODE_16_BIT
 #define DRV_TMR_ASYNC_WRITE_ENABLE_IDX2 false
 #define DRV_TMR_POWER_STATE_IDX2
 /*** Timer Driver 3 Configuration ***/
 #define DRV_TMR_PERIPHERAL_ID_IDX3 TMR_ID_1
 #define DRV_TMR_INTERRUPT_SOURCE_IDX3 INT_SOURCE_TIMER_1
 #define DRV_TMR_INTERRUPT_VECTOR_IDX3 INT_VECTOR_T1
 #define DRV_TMR_ISR_VECTOR_IDX3 _TIMER_1_VECTOR
 #define DRV_TMR_INTERRUPT_PRIORITY_IDX3 INT_PRIORITY_LEVEL2
 #define DRV_TMR_INTERRUPT_SUB_PRIORITY_IDX3 INT_SUBPRIORITY_LEVEL0
 #define DRV_TMR_CLOCK_SOURCE_IDX3 DRV_TMR_CLKSOURCE_INTERNAL
 #define DRV_TMR_PRESCALE_IDX3 TMR_PRESCALE_VALUE_256
 #define DRV_TMR_OPERATION_MODE_IDX3 DRV_TMR_OPERATION_MODE_16_BIT
 #define DRV_TMR_ASYNC_WRITE_ENABLE_IDX3 false
 #define DRV_TMR_POWER_STATE_IDX3
 /*** Timer Driver 4 Configuration ***/
 #define DRV_TMR_PERIPHERAL_ID_IDX4 TMR_ID_3
 #define DRV_TMR_INTERRUPT_SOURCE_IDX4 INT_SOURCE_TIMER_3
 #define DRV_TMR_INTERRUPT_VECTOR_IDX4 INT_VECTOR_T3
 #define DRV_TMR_ISR_VECTOR_IDX4 _TIMER_3_VECTOR
 #define DRV_TMR_INTERRUPT_PRIORITY_IDX4 INT_PRIORITY_LEVEL1
 #define DRV_TMR_INTERRUPT_SUB_PRIORITY_IDX4 INT_SUBPRIORITY_LEVEL0
 #define DRV_TMR_CLOCK_SOURCE_IDX4 DRV_TMR_CLKSOURCE_INTERNAL
 #define DRV_TMR_PRESCALE_IDX4 TMR_PRESCALE_VALUE_16
 #define DRV_TMR_OPERATION_MODE_IDX4 DRV_TMR_OPERATION_MODE_16_BIT
 #define DRV_TMR_ASYNC_WRITE_ENABLE_IDX4 false
 #define DRV_TMR_POWER_STATE_IDX4
  // *****************************************************************************
 /* USART Driver Configuration Options
 */
 #define DRV_USART_INSTANCES_NUMBER 1
 #define DRV_USART_CLIENTS_NUMBER 1
 #define DRV_USART_INTERRUPT_MODE false
 #define DRV_USART_BYTE_MODEL_SUPPORT true
 #define DRV_USART_READ_WRITE_MODEL_SUPPORT false
 #define DRV_USART_BUFFER_QUEUE_SUPPORT false
 // *****************************************************************************
 // *****************************************************************************
 // Section: Middleware & Other Library Configuration
 // *****************************************************************************
 // *****************************************************************************
 /*** USB Driver Configuration ***/
 /* Enables Device Support */
 #define DRV_USBHS_DEVICE_SUPPORT true
 /* Disable Host Support */
 #define DRV_USBHS_HOST_SUPPORT false
 /* Maximum USB driver instances */
 #define DRV_USBHS_INSTANCES_NUMBER 1
 /* Interrupt mode enabled */
 #define DRV_USBHS_INTERRUPT_MODE true
 /* Number of Endpoints used */
 #define DRV_USBHS_ENDPOINTS_NUMBER 2
 /*** USB Device Stack Configuration ***/
 /* The USB Device Layer will not initialize the USB Driver */
 #define USB_DEVICE_DRIVER_INITIALIZE_EXPLICIT
 /* Maximum device layer instances */
 #define USB_DEVICE_INSTANCES_NUMBER 1
 /* EP0 size in bytes */
 #define USB_DEVICE_EP0_BUFFER_SIZE 64
 /* Endpoint Transfer Queue Size combined for Read and write */
 #define USB_DEVICE_ENDPOINT_QUEUE_DEPTH_COMBINED 2
 // *****************************************************************************
 // *****************************************************************************
 // Section: Application Configuration
 // *****************************************************************************
 // *****************************************************************************
 /*** Application Defined Pins ***/
 /*** Functions for LED1 pin ***/
 #define LED1Toggle( ) PLIB_PORTS_PinToggle ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_12 )
 #define LED1On( ) PLIB_PORTS_PinSet ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_12 )
 #define LED1Off( ) PLIB_PORTS_PinClear ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_12 )
 #define LED1StateGet( ) PLIB_PORTS_PinGetLatched ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_12 )
 #define LED1StateSet( Value ) PLIB_PORTS_PinWrite ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_12 , Value )
 /*** Functions for LED2 pin ***/
 #define LED2Toggle( ) PLIB_PORTS_PinToggle ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_10 )
 #define LED2On( ) PLIB_PORTS_PinSet ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_10 )
 #define LED2Off( ) PLIB_PORTS_PinClear ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_10 )
 #define LED2StateGet( ) PLIB_PORTS_PinGetLatched ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_10 )
 #define LED2StateSet( Value ) PLIB_PORTS_PinWrite ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_10 , Value )
 /*** Functions for DMP_FIRE_LED pin ***/
 #define DMP_FIRE_LEDToggle( ) PLIB_PORTS_PinToggle ( PORTS_ID_0 , PORT_CHANNEL_E , PORTS_BIT_POS_9 )
 #define DMP_FIRE_LEDOn( ) PLIB_PORTS_PinSet ( PORTS_ID_0 , PORT_CHANNEL_E , PORTS_BIT_POS_9 )
 #define DMP_FIRE_LEDOff( ) PLIB_PORTS_PinClear ( PORTS_ID_0 , PORT_CHANNEL_E , PORTS_BIT_POS_9 )
 #define DMP_FIRE_LEDStateGet( ) PLIB_PORTS_PinGetLatched ( PORTS_ID_0 , PORT_CHANNEL_E , PORTS_BIT_POS_9 )
 #define DMP_FIRE_LEDStateSet( Value ) PLIB_PORTS_PinWrite ( PORTS_ID_0 , PORT_CHANNEL_E , PORTS_BIT_POS_9 , Value )
 /*** Functions for HVPS_ENB pin ***/
 #define HVPS_ENBToggle( ) PLIB_PORTS_PinToggle ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_13 )
 #define HVPS_ENBOn( ) PLIB_PORTS_PinSet ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_13 )
 #define HVPS_ENBOff( ) PLIB_PORTS_PinClear ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_13 )
 #define HVPS_ENBStateGet( ) PLIB_PORTS_PinGetLatched ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_13 )
 #define HVPS_ENBStateSet( Value ) PLIB_PORTS_PinWrite ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_13 , Value )
 /*** Functions for RLY_HVPS_OUT pin ***/
 #define RLY_HVPS_OUTToggle( ) PLIB_PORTS_PinToggle ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_14 )
 #define RLY_HVPS_OUTOn( ) PLIB_PORTS_PinSet ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_14 )
 #define RLY_HVPS_OUTOff( ) PLIB_PORTS_PinClear ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_14 )
 #define RLY_HVPS_OUTStateGet( ) PLIB_PORTS_PinGetLatched ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_14 )
 #define RLY_HVPS_OUTStateSet( Value ) PLIB_PORTS_PinWrite ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_14 , Value )
 /*** Functions for RLY_WL_SPS_POL pin ***/
 #define RLY_WL_SPS_POLToggle( ) PLIB_PORTS_PinToggle ( PORTS_ID_0 , PORT_CHANNEL_H , PORTS_BIT_POS_2 )
 #define RLY_WL_SPS_POLOn( ) PLIB_PORTS_PinSet ( PORTS_ID_0 , PORT_CHANNEL_H , PORTS_BIT_POS_2 )
 #define RLY_WL_SPS_POLOff( ) PLIB_PORTS_PinClear ( PORTS_ID_0 , PORT_CHANNEL_H , PORTS_BIT_POS_2 )
 #define RLY_WL_SPS_POLStateGet( ) PLIB_PORTS_PinGetLatched ( PORTS_ID_0 , PORT_CHANNEL_H , PORTS_BIT_POS_2 )
 #define RLY_WL_SPS_POLStateSet( Value ) PLIB_PORTS_PinWrite ( PORTS_ID_0 , PORT_CHANNEL_H , PORTS_BIT_POS_2 , Value )
 /*** Functions for RLY_LOG pin ***/
 #define RLY_LOGToggle( ) PLIB_PORTS_PinToggle ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_9 )
 #define RLY_LOGOn( ) PLIB_PORTS_PinSet ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_9 )
 #define RLY_LOGOff( ) PLIB_PORTS_PinClear ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_9 )
 #define RLY_LOGStateGet( ) PLIB_PORTS_PinGetLatched ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_9 )
 #define RLY_LOGStateSet( Value ) PLIB_PORTS_PinWrite ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_9 , Value )
 /*** Functions for RLY_DMP_FIRE pin ***/
 #define RLY_DMP_FIREToggle( ) PLIB_PORTS_PinToggle ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_10 )
 #define RLY_DMP_FIREOn( ) PLIB_PORTS_PinSet ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_10 )
 #define RLY_DMP_FIREOff( ) PLIB_PORTS_PinClear ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_10 )
 #define RLY_DMP_FIREStateGet( ) PLIB_PORTS_PinGetLatched ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_10 )
 #define RLY_DMP_FIREStateSet( Value ) PLIB_PORTS_PinWrite ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_10 , Value )
 /*** Functions for RLY_AUX pin ***/
 #define RLY_AUXToggle( ) PLIB_PORTS_PinToggle ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_11 )
 #define RLY_AUXOn( ) PLIB_PORTS_PinSet ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_11 )
 #define RLY_AUXOff( ) PLIB_PORTS_PinClear ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_11 )
 #define RLY_AUXStateGet( ) PLIB_PORTS_PinGetLatched ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_11 )
 #define RLY_AUXStateSet( Value ) PLIB_PORTS_PinWrite ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_11 , Value )
 /*** Functions for RLY_CCL pin ***/
 #define RLY_CCLToggle( ) PLIB_PORTS_PinToggle ( PORTS_ID_0 , PORT_CHANNEL_A , PORTS_BIT_POS_1 )
 #define RLY_CCLOn( ) PLIB_PORTS_PinSet ( PORTS_ID_0 , PORT_CHANNEL_A , PORTS_BIT_POS_1 )
 #define RLY_CCLOff( ) PLIB_PORTS_PinClear ( PORTS_ID_0 , PORT_CHANNEL_A , PORTS_BIT_POS_1 )
 #define RLY_CCLStateGet( ) PLIB_PORTS_PinGetLatched ( PORTS_ID_0 , PORT_CHANNEL_A , PORTS_BIT_POS_1 )
 #define RLY_CCLStateSet( Value ) PLIB_PORTS_PinWrite ( PORTS_ID_0 , PORT_CHANNEL_A , PORTS_BIT_POS_1 , Value )
 /*** Functions for RLY_WL_MON pin ***/
 #define RLY_WL_MONToggle( ) PLIB_PORTS_PinToggle ( PORTS_ID_0 , PORT_CHANNEL_F , PORTS_BIT_POS_12 )
 #define RLY_WL_MONOn( ) PLIB_PORTS_PinSet ( PORTS_ID_0 , PORT_CHANNEL_F , PORTS_BIT_POS_12 )
 #define RLY_WL_MONOff( ) PLIB_PORTS_PinClear ( PORTS_ID_0 , PORT_CHANNEL_F , PORTS_BIT_POS_12 )
 #define RLY_WL_MONStateGet( ) PLIB_PORTS_PinGetLatched ( PORTS_ID_0 , PORT_CHANNEL_F , PORTS_BIT_POS_12 )
 #define RLY_WL_MONStateSet( Value ) PLIB_PORTS_PinWrite ( PORTS_ID_0 , PORT_CHANNEL_F , PORTS_BIT_POS_12 , Value )
 /*** Functions for RLY_ARMCF pin ***/
 #define RLY_ARMCFToggle( ) PLIB_PORTS_PinToggle ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_13 )
 #define RLY_ARMCFOn( ) PLIB_PORTS_PinSet ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_13 )
 #define RLY_ARMCFOff( ) PLIB_PORTS_PinClear ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_13 )
 #define RLY_ARMCFStateGet( ) PLIB_PORTS_PinGetLatched ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_13 )
 #define RLY_ARMCFStateSet( Value ) PLIB_PORTS_PinWrite ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_13 , Value )
 /*** Functions for RLY_ARM pin ***/
 #define RLY_ARMToggle( ) PLIB_PORTS_PinToggle ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_14 )
 #define RLY_ARMOn( ) PLIB_PORTS_PinSet ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_14 )
 #define RLY_ARMOff( ) PLIB_PORTS_PinClear ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_14 )
 #define RLY_ARMStateGet( ) PLIB_PORTS_PinGetLatched ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_14 )
 #define RLY_ARMStateSet( Value ) PLIB_PORTS_PinWrite ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_14 , Value )
 /*** Functions for TPAN1 pin ***/
 #define TPAN1Toggle( ) PLIB_PORTS_PinToggle ( PORTS_ID_0 , PORT_CHANNEL_H , PORTS_BIT_POS_10 )
 #define TPAN1On( ) PLIB_PORTS_PinSet ( PORTS_ID_0 , PORT_CHANNEL_H , PORTS_BIT_POS_10 )
 #define TPAN1Off( ) PLIB_PORTS_PinClear ( PORTS_ID_0 , PORT_CHANNEL_H , PORTS_BIT_POS_10 )
 #define TPAN1StateGet( ) PLIB_PORTS_PinGetLatched ( PORTS_ID_0 , PORT_CHANNEL_H , PORTS_BIT_POS_10 )
 #define TPAN1StateSet( Value ) PLIB_PORTS_PinWrite ( PORTS_ID_0 , PORT_CHANNEL_H , PORTS_BIT_POS_10 , Value )
 /*** Functions for TPAN2 pin ***/
 #define TPAN2Toggle( ) PLIB_PORTS_PinToggle ( PORTS_ID_0 , PORT_CHANNEL_H , PORTS_BIT_POS_11 )
 #define TPAN2On( ) PLIB_PORTS_PinSet ( PORTS_ID_0 , PORT_CHANNEL_H , PORTS_BIT_POS_11 )
 #define TPAN2Off( ) PLIB_PORTS_PinClear ( PORTS_ID_0 , PORT_CHANNEL_H , PORTS_BIT_POS_11 )
 #define TPAN2StateGet( ) PLIB_PORTS_PinGetLatched ( PORTS_ID_0 , PORT_CHANNEL_H , PORTS_BIT_POS_11 )
 #define TPAN2StateSet( Value ) PLIB_PORTS_PinWrite ( PORTS_ID_0 , PORT_CHANNEL_H , PORTS_BIT_POS_11 , Value )
 /*** Functions for FSK_DAC_CS pin ***/
 #define FSK_DAC_CSToggle( ) PLIB_PORTS_PinToggle ( PORTS_ID_0 , PORT_CHANNEL_A , PORTS_BIT_POS_4 )
 #define FSK_DAC_CSOn( ) PLIB_PORTS_PinSet ( PORTS_ID_0 , PORT_CHANNEL_A , PORTS_BIT_POS_4 )
 #define FSK_DAC_CSOff( ) PLIB_PORTS_PinClear ( PORTS_ID_0 , PORT_CHANNEL_A , PORTS_BIT_POS_4 )
 #define FSK_DAC_CSStateGet( ) PLIB_PORTS_PinGetLatched ( PORTS_ID_0 , PORT_CHANNEL_A , PORTS_BIT_POS_4 )
 #define FSK_DAC_CSStateSet( Value ) PLIB_PORTS_PinWrite ( PORTS_ID_0 , PORT_CHANNEL_A , PORTS_BIT_POS_4 , Value )
 /*** Functions for RLY_COMM pin ***/
 #define RLY_COMMToggle( ) PLIB_PORTS_PinToggle ( PORTS_ID_0 , PORT_CHANNEL_H , PORTS_BIT_POS_14 )
 #define RLY_COMMOn( ) PLIB_PORTS_PinSet ( PORTS_ID_0 , PORT_CHANNEL_H , PORTS_BIT_POS_14 )
 #define RLY_COMMOff( ) PLIB_PORTS_PinClear ( PORTS_ID_0 , PORT_CHANNEL_H , PORTS_BIT_POS_14 )
 #define RLY_COMMStateGet( ) PLIB_PORTS_PinGetLatched ( PORTS_ID_0 , PORT_CHANNEL_H , PORTS_BIT_POS_14 )
 #define RLY_COMMStateSet( Value ) PLIB_PORTS_PinWrite ( PORTS_ID_0 , PORT_CHANNEL_H , PORTS_BIT_POS_14 , Value )
 /*** Functions for FSK_DAC_CLR pin ***/
 #define FSK_DAC_CLRToggle( ) PLIB_PORTS_PinToggle ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_7 )
 #define FSK_DAC_CLROn( ) PLIB_PORTS_PinSet ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_7 )
 #define FSK_DAC_CLROff( ) PLIB_PORTS_PinClear ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_7 )
 #define FSK_DAC_CLRStateGet( ) PLIB_PORTS_PinGetLatched ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_7 )
 #define FSK_DAC_CLRStateSet( Value ) PLIB_PORTS_PinWrite ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_7 , Value )
 /*** Functions for WL_CPS_SW pin ***/
 #define WL_CPS_SWToggle( ) PLIB_PORTS_PinToggle ( PORTS_ID_0 , PORT_CHANNEL_G , PORTS_BIT_POS_13 )
 #define WL_CPS_SWOn( ) PLIB_PORTS_PinSet ( PORTS_ID_0 , PORT_CHANNEL_G , PORTS_BIT_POS_13 )
 #define WL_CPS_SWOff( ) PLIB_PORTS_PinClear ( PORTS_ID_0 , PORT_CHANNEL_G , PORTS_BIT_POS_13 )
 #define WL_CPS_SWStateGet( ) PLIB_PORTS_PinGetLatched ( PORTS_ID_0 , PORT_CHANNEL_G , PORTS_BIT_POS_13 )
 #define WL_CPS_SWStateSet( Value ) PLIB_PORTS_PinWrite ( PORTS_ID_0 , PORT_CHANNEL_G , PORTS_BIT_POS_13 , Value )
 /*** Functions for HVPS_SW pin ***/
 #define HVPS_SWStateGet( ) PLIB_PORTS_PinGet ( PORTS_ID_0 , PORT_CHANNEL_A , PORTS_BIT_POS_5 )
 /*** Functions for MAN_SIG pin ***/
 #define MAN_SIGStateGet( ) PLIB_PORTS_PinGet ( PORTS_ID_0 , PORT_CHANNEL_A , PORTS_BIT_POS_0 )
 /*** Functions for DMP_FIRE_SW pin ***/
 #define DMP_FIRE_SWStateGet( ) PLIB_PORTS_PinGet ( PORTS_ID_0 , PORT_CHANNEL_E , PORTS_BIT_POS_8 )
 /*** Functions for NEG_SW pin ***/
 #define NEG_SWStateGet( ) PLIB_PORTS_PinGet ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_4 )
 /*** Functions for POS_SW pin ***/
 #define POS_SWStateGet( ) PLIB_PORTS_PinGet ( PORTS_ID_0 , PORT_CHANNEL_J , PORTS_BIT_POS_15 )
 /*** Functions for DRUM1_SW pin ***/
 #define DRUM1_SWStateGet( ) PLIB_PORTS_PinGet ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_2 )
 /*** Functions for SAFE_SW pin ***/
 #define SAFE_SWStateGet( ) PLIB_PORTS_PinGet ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_1 )
 /*** Functions for DRUM2_SW pin ***/
 #define DRUM2_SWStateGet( ) PLIB_PORTS_PinGet ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_0 )
 /*** Functions for LOG_SW pin ***/
 #define LOG_SWStateGet( ) PLIB_PORTS_PinGet ( PORTS_ID_0 , PORT_CHANNEL_H , PORTS_BIT_POS_3 )
 /*** Functions for AUX_SW pin ***/
 #define AUX_SWStateGet( ) PLIB_PORTS_PinGet ( PORTS_ID_0 , PORT_CHANNEL_B , PORTS_BIT_POS_8 )
 /*** Functions for ARMCF_SW pin ***/
 #define ARMCF_SWStateGet( ) PLIB_PORTS_PinGet ( PORTS_ID_0 , PORT_CHANNEL_K , PORTS_BIT_POS_1 )
 /*** Functions for ARM_SW pin ***/
 #define ARM_SWStateGet( ) PLIB_PORTS_PinGet ( PORTS_ID_0 , PORT_CHANNEL_K , PORTS_BIT_POS_2 )
 /*** Functions for ARMCF_AUTO_SW pin ***/
 #define ARMCF_AUTO_SWStateGet( ) PLIB_PORTS_PinGet ( PORTS_ID_0 , PORT_CHANNEL_F , PORTS_BIT_POS_13 )
 /*** Functions for FIRE_SW_OFF pin ***/
 #define FIRE_SW_OFFStateGet( ) PLIB_PORTS_PinGet ( PORTS_ID_0 , PORT_CHANNEL_F , PORTS_BIT_POS_8 )
 /*** Functions for FIRE_SW_ON pin ***/
 #define FIRE_SW_ONStateGet( ) PLIB_PORTS_PinGet ( PORTS_ID_0 , PORT_CHANNEL_H , PORTS_BIT_POS_8 )
 /*** Functions for WL_SPS_POS_DET pin ***/
 #define WL_SPS_POS_DETStateGet( ) PLIB_PORTS_PinGet ( PORTS_ID_0 , PORT_CHANNEL_H , PORTS_BIT_POS_12 )
 /*** Functions for WL_SPS_NEG_DET pin ***/
 #define WL_SPS_NEG_DETStateGet( ) PLIB_PORTS_PinGet ( PORTS_ID_0 , PORT_CHANNEL_H , PORTS_BIT_POS_13 )
 #define MAN_CN_PORT_CHANNEL PORT_CHANNEL_A
 #define MAN_CN_PORT_BIT PORTS_BIT_POS_0
 #define MAN_CN_PORT_INTERRUPT INT_SOURCE_CHANGE_NOTICE_A
 #define HVPS_CN_PORT_CHANNEL PORT_CHANNEL_J
 #define HVPS_CN_PORT_BIT PORTS_BIT_POS_11
 #define HVPS_CN_PORT_INTERRUPT INT_SOURCE_CHANGE_NOTICE_J
 /*** Application Instance 0 Configuration ***/
 //DOM-IGNORE-BEGIN
 //DOM-IGNORE-END
        // _SYSTEM_CONFIG_H
 /*******************************************************************************
  End of File
 */
 #endif /*00 C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\system_config\default\system_config.h*/
 /*   CLOSE_FILE Include File */

 /* OPEN FILE C:\microchip\harmony\v2_06\framework\driver\driver_common.h */
 /*******************************************************************************
  Driver Common Header Definitions
  Company:
  Microchip Technology Inc.
  File Name:
  drv_common.h
  Summary:
  This file defines the common macros and definitions used by the driver
  definition and implementation headers.
  Description:
  This file defines the common macros and definitions used by the driver
  definition and the implementation header.
  Remarks:
  The directory in which this file resides should be added to the compiler's
  search path for header files.
  *******************************************************************************/
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2010-2013 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS-IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
  *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _DRV_COMMON_H
 #define _DRV_COMMON_H
 #include <stdint.h>
 #include <stddef.h>
 // *****************************************************************************
 /* Device Driver I/O Intent
  Summary:
  Identifies the intended usage of the device when it is opened.
  Description:
  This enumeration identifies the intended usage of the device when the
  caller opens the device. It identifies the desired behavior of the device
  driver for the following:
  * Blocking or non-blocking I/O behavior (do I/O calls such as read and write
  block until the operation is finished or do they return immediately and
  require the caller to call another routine to check the status of the
  operation)
  * Support reading and/or writing of data from/to the device
  * Identify the buffering behavior (sometimes called "double buffering" of
  the driver. Indicates if the driver should maintain its own read/write
  buffers and copy data to/from these buffers to/from the caller's buffers.
  * Identify the DMA behavior of the peripheral
  Remarks:
  The buffer allocation method is not identified by this enumeration. Buffers
  can be allocated statically at build time, dynamically at run-time, or
  even allocated by the caller and passed to the driver for its own usage if
  a driver-specific routine is provided for such. This choice is left to
  the design of the individual driver and is considered part of its
  interface.
  These values can be considered "flags". One selection from each of the
  groups below can be ORed together to create the complete value passed
  to the driver's open routine.
 */

 typedef
   enum
   {
     /* Read */
     DRV_IO_INTENT_READ /*DOM-IGNORE-BEGIN*/
     = 1 << 0                                         /* DOM-IGNORE-END*/
     ,
     /* Write */
     DRV_IO_INTENT_WRITE /*DOM-IGNORE-BEGIN*/
     = 1 << 1                                          /* DOM-IGNORE-END*/
     ,
     /* Read and Write*/
     DRV_IO_INTENT_READWRITE /*DOM-IGNORE-BEGIN*/
     = DRV_IO_INTENT_READ | DRV_IO_INTENT_WRITE       /* DOM-IGNORE-END*/
     ,
     /* The driver will block and will return when the operation is complete */
     DRV_IO_INTENT_BLOCKING /*DOM-IGNORE-BEGIN*/
     = 0 << 2                                             /* DOM-IGNORE-END*/
     ,
     /* The driver will return immediately */
     DRV_IO_INTENT_NONBLOCKING /*DOM-IGNORE-BEGIN*/
     = 1 << 2                                                /* DOM-IGNORE-END*/
     ,
     /* The driver will support only one client at a time */
     DRV_IO_INTENT_EXCLUSIVE /*DOM-IGNORE-BEGIN*/
     = 1 << 3                                              /* DOM-IGNORE-END*/
     ,
     /* The driver will support multiple clients at a time */
     DRV_IO_INTENT_SHARED /*DOM-IGNORE-BEGIN*/
     = 0 << 3                                           /* DOM-IGNORE-END*/
   } DRV_IO_INTENT ;
 // *****************************************************************************
 /* Driver Client Status
  Summary:
  Identifies the current status/state of a client's connection to a driver.
  Description:
  This enumeration identifies the current status/state of a client's link to
  a driver.
  Remarks:
  The enumeration used as the return type for the client-level status routines
  defined by each device driver or system module (for example,
  DRV_USART_ClientStatus) must be based on the values in this enumeration.
 */

 typedef
   enum
   {
     /* Indicates that a driver-specific error has occurred. */
     DRV_CLIENT_STATUS_ERROR_EXTENDED = - 10 ,
     /* An unspecified error has occurred.*/
     DRV_CLIENT_STATUS_ERROR = - 1 ,
     /* The driver is closed, no operations for this client are ongoing,
     and/or the given handle is invalid. */
     DRV_CLIENT_STATUS_CLOSED = 0 ,
     /* The driver is currently busy and cannot start additional operations. */
     DRV_CLIENT_STATUS_BUSY = 1 ,
     /* The module is running and ready for additional operations */
     DRV_CLIENT_STATUS_READY = 2 ,
     /* Indicates that the module is in a driver-specific ready/run state. */
     DRV_CLIENT_STATUS_READY_EXTENDED = 10
   } DRV_CLIENT_STATUS ;
 // *****************************************************************************
 /* Device Driver Blocking Status Macro
  Summary:
  Returns if the I/O intent provided is blocking
  Description:
  This macro returns if the I/O intent provided is blocking.
  Remarks:
  None.
 */
 #define DRV_IO_ISBLOCKING( intent ) ( intent & DRV_IO_INTENT_BLOCKING )
 // *****************************************************************************
 /* Device Driver Non Blocking Status Macro
  Summary:
  Returns if the I/O intent provided is non-blocking.
  Description:
  This macro returns if the I/ intent provided is non-blocking.
  Remarks:
  None.
 */
 #define DRV_IO_ISNONBLOCKING( intent ) ( intent & DRV_IO_INTENT_NONBLOCKING )
 // *****************************************************************************
 /* Device Driver Exclusive Status Macro
  Summary:
  Returns if the I/O intent provided is non-blocking.
  Description:
  This macro returns if the I/O intent provided is non-blocking.
  Remarks:
  None.
 */
 #define DRV_IO_ISEXCLUSIVE( intent ) ( intent & DRV_IO_INTENT_EXCLUSIVE )
 // *****************************************************************************
 /* Device Driver IO Buffer Identifier
  Summary:
  Identifies to which buffer a device operation will apply.
  Description:
  This enumeration identifies to which buffer (read, write, both, or neither)
  a device operation will apply. This is used for "flush" (or similar)
  operations.
 */

 typedef
   enum
   {
     // Operation does not apply to any buffer
     DRV_IO_BUFFER_TYPE_NONE = 0x00 ,
     // Operation applies to read buffer
     DRV_IO_BUFFER_TYPE_READ = 0x01 ,
     // Operation applies to write buffer
     DRV_IO_BUFFER_TYPE_WRITE = 0x02 ,
     // Operation applies to both read and write buffers
     DRV_IO_BUFFER_TYPE_RW = DRV_IO_BUFFER_TYPE_READ | DRV_IO_BUFFER_TYPE_WRITE
   } DRV_IO_BUFFER_TYPES ;
 // *****************************************************************************
 /* Device Handle
  Summary:
  Handle to an opened device driver.
  Description:
  This handle identifies the open instance of a device driver. It must be
  passed to all other driver routines (except the initialization, deinitialization,
  or power routines) to identify the caller.
  Remarks:
  Every application or module that wants to use a driver must first call
  the driver's open routine. This is the only routine that is absolutely
  required for every driver.
  If a driver is unable to allow an additional module to use it, it must then
  return the special value DRV_HANDLE_INVALID. Callers should check the
  handle returned for this value to ensure this value was not returned before
  attempting to call any other driver routines using the handle.
 */

 typedef
 uintptr_t
   DRV_HANDLE ;
 // *****************************************************************************
 /* Invalid Device Handle
  Summary:
  Invalid device handle.
  Description:
  If a driver is unable to allow an additional module to use it, it must then
  return the special value DRV_HANDLE_INVALID. Callers should check the
  handle returned for this value to ensure this value was not returned before
  attempting to call any other driver routines using the handle.
  Remarks:
  None.
 */
 #define DRV_HANDLE_INVALID ( ( ( DRV_HANDLE ) - 1 ) )
 // *****************************************************************************
 /* Not supported configuration
  Summary:
  Not supported configuration.
  Description:
  If the configuration option is not supported on an instance of the
  peripheral, use this macro to equate to that configuration. This option
  should be listed as a possible value in the description of that
  configuration option.
 */
 #define DRV_CONFIG_NOT_SUPPORTED ( ( ( unsigned short ) - 1 ) )
 // *****************************************************************************
 /* Unsupported Attribute Abstraction
  Summary:
  Abstracts the use of the unsupported attribute defined by the compiler.
  Description:
  This macro nulls the definition of the _PLIB_UNSUPPORTED macro, to support
  compilation of the drivers for all different variants.
  Example:
  void _PLIB_UNSUPPORTED PLIB_USART_Enable(USART_MODULE_ID index);
  This function will not generate a compiler error if the interface is not
  defined for the selected device.
  Remarks:
         None.
 */
 #define _PLIB_UNSUPPORTED
        //_DRV_COMMON_H
 /*******************************************************************************
  End of File
 */
 #endif /*00 C:\microchip\harmony\v2_06\framework\driver\driver_common.h*/
 /*   CLOSE_FILE Include File */

 #include "system/common/sys_module.h"
 // *****************************************************************************
 /* IC Driver Module Index Numbers
  Summary:
  IC driver index definitions.
  Description:
  These constants provide IC Driver index definitions.
  Remarks:
  These constants should be used in place of hard-coded numeric literals.
  These values should be passed into the DRV_IC_Initialize and
  DRV_IC_Open routines to identify the driver instance in use.
 */
 #define DRV_IC_INDEX_0 0
 #define DRV_IC_INDEX_1 1
 #define DRV_IC_INDEX_2 2
 #define DRV_IC_INDEX_3 3
 #define DRV_IC_INDEX_4 4
 #define DRV_IC_INDEX_5 5
 #define DRV_IC_INDEX_6 6
 #define DRV_IC_INDEX_7 7
 #define DRV_IC_INDEX_8 8
 #define DRV_IC_INDEX_9 9
 #define DRV_IC_INDEX_10 10
 #define DRV_IC_INDEX_11 11
 #define DRV_IC_INDEX_12 12
 #define DRV_IC_INDEX_13 13
 #define DRV_IC_INDEX_14 14
 #define DRV_IC_INDEX_15 15
 // *****************************************************************************
 // *****************************************************************************
 // Section: Interface Headers for the static driver
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Function:
  SYS_MODULE_OBJ DRV_IC_Initialize(const SYS_MODULE_INDEX index,
  const SYS_MODULE_INIT * const init);
  Summary:
  Initializes the Input Capture instance for the specified driver index.
  <p><b>Implementation:</b> Static</p>
  Description:
  This routine initializes the Input Capture driver instance for the specified
         driver instance, making it ready for clients to use it. The initialization
         routine is specified by the MHC parameters. The driver instance index is
  independent of the Input Capture module ID. For example, driver instance 0
         can be assigned to Input Capture 2.
  Precondition:
  None.
  Parameters:
  None.
  Returns:
  None.
  Remarks:
  This routine must be called before any other Input Capture routine is called.
  This routine should only be called once during system initialization.
 */

 SYS_MODULE_OBJ
   DRV_IC_Initialize (
   const SYS_MODULE_INDEX index ,
   const SYS_MODULE_INIT * const init ) ;
 // *****************************************************************************
 /* Function:
 DRV_HANDLE DRV_IC_Open(const SYS_MODULE_INDEX drvIndex, const DRV_IO_INTENT intent)
  Summary:
  Opens the Input Capture instance for the specified driver index.
  <p><b>Implementation:</b> Static</p>
  Description:
  This routine starts the Input Capture driver for the specified driver
  index, starting an input capture.
  Precondition:
  DRV_IC_Initialize has been called.
  Parameters:
  None.
  Returns:
  None.
  Remarks:
  None.
 */

 DRV_HANDLE
   DRV_IC_Open (
   const SYS_MODULE_INDEX drvIndex ,
   const DRV_IO_INTENT intent ) ;
 // *****************************************************************************
 /* Function:
  void DRV_IC_Close(DRV_HANDLE handle)
  Summary:
  Closes the Input Capture instance for the specified driver index.
  <p><b>Implementation:</b> Static</p>
  Description:
  This routine stops the Input Capture driver for the specified driver
  index, stopping an input capture.
  Precondition:
  DRV_IC_Initialize has been called.
  Parameters:
  None.
  Returns:
  None.
  Remarks:
  None.
 */

 void
   DRV_IC_Close (
   DRV_HANDLE handle ) ;
 // *****************************************************************************
 /* Function:
 DRV_HANDLE DRV_IC_Start(const SYS_MODULE_INDEX drvIndex, const DRV_IO_INTENT intent)
  Summary:
  Starts the Input Capture instance for the specified driver index.
  <p><b>Implementation:</b> Static</p>
  Description:
  This routine starts the Input Capture driver for the specified driver
  index, starting an input capture.
  Precondition:
  DRV_IC_Initialize has been called.
  Parameters:
  None.
  Returns:
  None.
  Remarks:
  None.
 */

 DRV_HANDLE
   DRV_IC_Start (
   const SYS_MODULE_INDEX drvIndex ,
   const DRV_IO_INTENT intent ) ;
 // *****************************************************************************
 /* Function:
  void DRV_IC_Stop(DRV_HANDLE handle)
  Summary:
  Stops the Input Capture instance for the specified driver index.
  <p><b>Implementation:</b> Static</p>
  Description:
  This routine stops the Input Capture driver for the specified driver
  index, stopping an input capture.
  Precondition:
  DRV_IC_Initialize has been called.
  Parameters:
  None.
  Returns:
  None.
  Remarks:
  None.
 */

 void
   DRV_IC_Stop (
   DRV_HANDLE handle ) ;
 // *****************************************************************************
 /* Function:
  uint32_t DRV_IC_Capture32BitDataRead(DRV_HANDLE handle)
  Summary:
  Reads the 32-bit Input Capture for the specified driver index.
  <p><b>Implementation:</b> Static</p>
  Description:
  This routine reads the 32-bit data for the specified driver index
  Precondition:
  DRV_IC_Initialize has been called.
  Parameters:
  None.
  Returns:
  uint32_t value of the data read from the Input Capture.
  Remarks:
  None.
 */

 uint32_t
   DRV_IC_Capture32BitDataRead (
   DRV_HANDLE handle ) ;
 // *****************************************************************************
 /* Function:
  uint16_t DRV_IC_Capture16BitDataRead(DRV_HANDLE handle)
  Summary:
  Reads the 16-bit Input Capture for the specified driver index.
  <p><b>Implementation:</b> Static</p>
  Description:
  This routine reads the 16-bit data for the specified driver index.
  Precondition:
  DRV_IC_Initialize has been called.
  Parameters:
  None.
  Returns:
  uint16_t value of the data read from the Input Capture.
  Remarks:
  None.
 */

 uint16_t
   DRV_IC_Capture16BitDataRead (
   DRV_HANDLE handle ) ;
 // *****************************************************************************
 /* Function:
  bool DRV_IC_BufferIsEmpty(DRV_HANDLE handle)
  Summary:
  Returns the Input Capture instance buffer empty status for the specified driver
         index.
  <p><b>Implementation:</b> Static</p>
  Description:
  Returns the Input Capture instance buffer empty status for the specified driver
         index. The function should be called to determine whether or not the IC buffer
         has data.
  Precondition:
  DRV_IC_Initialize has been called.
  Parameters:
  None.
  Returns:
  Boolean
         - 1 - Buffer is empty
         - 0 - Buffer is not empty
  Remarks:
  None.
 */

 bool
   DRV_IC_BufferIsEmpty (
   DRV_HANDLE handle ) ;
 /* OPEN FILE C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\system_config\default\framework\driver\ic\drv_ic_static.h */
 /*******************************************************************************
  IC Driver Interface Declarations for Static Single Instance Driver
  Company:
  Microchip Technology Inc.
  File Name:
  drv_ic_static.h
  Summary:
  IC driver interface declarations for the static single instance driver.
  Description:
  The IC device driver provides a simple interface to manage the IC
  modules on Microchip microcontrollers. This file defines the interface
  Declarations for the IC driver.

  Remarks:
  Static interfaces incorporate the driver instance number within the names
  of the routines, eliminating the need for an object ID or object handle.

  Static single-open interfaces also eliminate the need for the open handle.
 *******************************************************************************/
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2013 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
 *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _DRV_IC_STATIC_H
 #define _DRV_IC_STATIC_H
 #define DRV_IC_Open( drvIndex , intent ) ( drvIndex )
 #define DRV_IC_Close( handle )
 // *****************************************************************************
 // *****************************************************************************
 // Section: Interface Headers for Instance 0 for the static driver
 // *****************************************************************************
 // *****************************************************************************

 void
   DRV_IC0_Initialize ( void ) ;

 void
   DRV_IC0_Start ( void ) ;

 void
   DRV_IC0_Stop ( void ) ;

 uint32_t
   DRV_IC0_Capture32BitDataRead ( void ) ;

 uint16_t
   DRV_IC0_Capture16BitDataRead ( void ) ;

 bool
   DRV_IC0_BufferIsEmpty ( void ) ;
        // #ifndef _DRV_IC_STATIC_H
 /*******************************************************************************
  End of File
 */

 #endif /*00 C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\system_config\default\framework\driver\ic\drv_ic_static.h*/
 /*   CLOSE_FILE Include File */

        // #ifndef _DRV_IC_H
 /*******************************************************************************
  End of File
 */
 #endif /*00 C:\microchip\harmony\v2_06\framework\driver\ic\drv_ic.h*/
 /*   CLOSE_FILE Include File */

 #include "system/devcon/sys_devcon.h"
 #include "system/clk/sys_clk.h"
 #include "system/int/sys_int.h"
 #include "system/tmr/sys_tmr.h"
 /* OPEN FILE C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\system_config\default\framework\driver\adc\drv_adc_static.h */
 /*******************************************************************************
  ADC Driver Interface Declarations for Static Single Instance Driver
  Company:
  Microchip Technology Inc.
  File Name:
  drv_adc_static.h
  Summary:
  ADC driver interface declarations for the static single instance driver.
  Description:
  The ADC device driver provides a simple interface to manage the ADC
  modules on Microchip microcontrollers. This file defines the interface
  Declarations for the ADC driver.

  Remarks:
  Static interfaces incorporate the driver instance number within the names
  of the routines, eliminating the need for an object ID or object handle.

  Static single-open interfaces also eliminate the need for the open handle.
 *******************************************************************************/
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2013 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
 *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _DRV_ADC_STATIC_H
 #define _DRV_ADC_STATIC_H
 #include <stdbool.h>
 #include "C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\system_config\default\system_config.h"  /* LDRA full path */
 #include "peripheral/adchs/plib_adchs.h"
 #include "peripheral/int/plib_int.h"

 typedef
   enum
   {
     DRV_ADC_ID_1 = ADCHS_ID_0 ,
     DRV_ADCHS_NUMBER_OF_MODULES
   } DRV_ADC_MODULE_ID ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: Interface Headers for ADC Static Driver
 // *****************************************************************************
 // *****************************************************************************

 void
   DRV_ADC_Initialize ( void ) ;

 inline void
   DRV_ADC_DeInitialize ( void ) ;

 inline void
   DRV_ADC0_Open ( void ) ;

 inline void
   DRV_ADC0_Close ( void ) ;

 inline void
   DRV_ADC1_Open ( void ) ;

 inline void
   DRV_ADC1_Close ( void ) ;

 inline void
   DRV_ADC_Start ( void ) ;

 inline void
   DRV_ADC_Stop ( void ) ;

 uint32_t
   DRV_ADC_SamplesRead (
   uint8_t bufIndex ) ;

 bool
   DRV_ADC_SamplesAvailable (
   uint8_t bufIndex ) ;
        // #ifndef _DRV_ADC_STATIC_H
 /*******************************************************************************
  End of File
 */

 #endif /*00 C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\system_config\default\framework\driver\adc\drv_adc_static.h*/
 /*   CLOSE_FILE Include File */

 /* OPEN FILE C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\system_config\default\framework\driver\tmr\drv_tmr_static.h */
 /*******************************************************************************
  Timer Driver Interface Declarations for Static Single Instance Driver
  Company:
  Microchip Technology Inc.
  File Name:
  drv_tmr_static.h
  Summary:
  Timer driver interface declarations for the static single instance driver.
  Description:
  The Timer device driver provides a simple interface to manage the Timer
  modules on Microchip microcontrollers. This file defines the interface
  Declarations for the TMR driver.

  Remarks:
  Static interfaces incorporate the driver instance number within the names
  of the routines, eliminating the need for an object ID or object handle.

  Static single-open interfaces also eliminate the need for the open handle.
 *******************************************************************************/
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2014 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTOCULAR PURPOSE.
 IN NO EVENT SHALL MOCROCHIP OR ITS LOCENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STROCT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVOCES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
 *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _DRV_TMR_STATIC_H
 #define _DRV_TMR_STATIC_H
 // *****************************************************************************
 // *****************************************************************************
 // Section: Include Headers
 // *****************************************************************************
 // *****************************************************************************
 #include <stdint.h>
 /* OPEN FILE C:\microchip\harmony\v2_06\framework\driver\tmr\drv_tmr.h */
 /*******************************************************************************
  Timer Device Driver Interface Definition
  Company:
  Microchip Technology Inc.
  File Name:
  drv_tmr.h
  Summary:
  Timer device driver interface header file.
  Description:
  This header file contains the function prototypes and definitions of the
  data types and constants that make up the interface to the Timer device
  driver.
 *******************************************************************************/
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2013-2014 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
 *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _DRV_TMR_H
 #define _DRV_TMR_H
 // *****************************************************************************
 // *****************************************************************************
 // Section: File includes
 // *****************************************************************************
 // *****************************************************************************
 #include "C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\system_config\default\system_config.h"  /* LDRA full path */
 #include "C:\microchip\harmony\v2_06\framework\driver\driver_common.h"  /* LDRA full path */
 #include "peripheral/tmr/plib_tmr.h"
 /* OPEN FILE C:\microchip\harmony\v2_06\framework\driver\tmr\tmr_definitions_pic32m.h */
 /*******************************************************************************
  Timer Device Driver Interface Definition
  Company:
  Microchip Technology Inc.
  File Name:
  tmr_definitions_pic32m.h
  Summary:
  Timer device driver definitions header file.
  Description:
  This header file contains the definitions of the
  data types and constants that make up the interface to the Timer device
  driver.
 *******************************************************************************/
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2013-2014 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
 *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _TMR_DEFINITIONS_PIC32M_H
 #define _TMR_DEFINITIONS_PIC32M_H
 // DOM-IGNORE-BEGIN
 // DOM-IGNORE-END

 typedef
   enum
   {
     /* Clock input to the timer module is internal(Peripheral Clock) */
     DRV_TMR_CLKSOURCE_INTERNAL
             /*DOM-IGNORE-BEGIN*/
     = 0x00                              /*DOM-IGNORE-END*/
     ,
     /* Clock input to the timer module is from T1CK pin (external)
        with clock synchronization enabled */
     DRV_TMR_CLKSOURCE_EXTERNAL_SYNCHRONOUS
             /*DOM-IGNORE-BEGIN*/
     = 0x01                              /*DOM-IGNORE-END*/
     ,
     /* Clock input to the timer module is from T1CK pin (external)
     with clock synchronization disabled */
     DRV_TMR_CLKSOURCE_EXTERNAL_ASYNCHRONOUS
             /*DOM-IGNORE-BEGIN*/
     = 0x11                              /*DOM-IGNORE-END*/
     ,
     /* Clock input to the timer module is from secondary oscillator (external)
        with clock synchronization enabled */
     DRV_TMR_CLKSOURCE_SECONDARY_OSCILLATOR_SYNCHRONOUS
             /*DOM-IGNORE-BEGIN*/
     = 0x02                              /*DOM-IGNORE-END*/
     ,
     /* Clock input to the timer module is from secondary oscillator (external)
     with clock synchronization disabled */
     DRV_TMR_CLKSOURCE_SECONDARY_OSCILLATOR_ASYNCHRONOUS
             /*DOM-IGNORE-BEGIN*/
     = 0x12                              /*DOM-IGNORE-END*/
     ,
     /* Clock input to the timer module is from LPRC
        with clock synchronization enabled */
     DRV_TMR_CLKSOURCE_LPRC_OSCILLATOR_SYNCHRONOUS
             /*DOM-IGNORE-BEGIN*/
     = 0x03                              /*DOM-IGNORE-END*/
     ,
     /* Clock input to the timer module is from LPRC
     with clock synchronization disabled */
     DRV_TMR_CLKSOURCE_LPRC_OSCILLATOR_ASYNCHRONOUS
             /*DOM-IGNORE-BEGIN*/
     = 0x13                              /*DOM-IGNORE-END*/
   } DRV_TMR_CLK_SOURCES ;
 //DOM-IGNORE-BEGIN
 //DOM-IGNORE-END
        // #ifndef _DRV_TMR_H
 /*******************************************************************************
  End of File
 */

 #endif /*00 C:\microchip\harmony\v2_06\framework\driver\tmr\tmr_definitions_pic32m.h*/
 /*   CLOSE_FILE Include File */

 #include "system/int/sys_int.h"            // System Interrupt Definitions
 #include "system/clk/sys_clk.h"
 // DOM-IGNORE-BEGIN
 // DOM-IGNORE-END
 // *****************************************************************************
 // *****************************************************************************
 // Section: TMR Driver Data Types
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Timer Driver Module Index Numbers
   Summary:
     Timer driver index definitions
   Description:
     These constants provide Timer driver index definitions.
   Remarks:
     These constants should be used in place of hard-coded numeric literals.
     These values should be passed into the DRV_TMR_Initialize and DRV_TMR_Open
     functions to identify the driver instance in use.
 */
 #define DRV_TMR_INDEX_0 0
 #define DRV_TMR_INDEX_1 1
 #define DRV_TMR_INDEX_2 2
 #define DRV_TMR_INDEX_3 3
 #define DRV_TMR_INDEX_4 4
 #define DRV_TMR_INDEX_5 5
 #define DRV_TMR_INDEX_6 6
 #define DRV_TMR_INDEX_7 7
 #define DRV_TMR_INDEX_8 8
 #define DRV_TMR_INDEX_9 9
 #define DRV_TMR_INDEX_10 10
 #define DRV_TMR_INDEX_11 11
 // *****************************************************************************
 /* Timer Driver Module Index Count
   Summary:
     Number of valid Timer driver indices.
   Description:
     This constant identifies Timer driver index definitions.
   Remarks:
     This constant should be used in place of hard-coded numeric literals.
     This value is device-specific.
 */
 #define DRV_TMR_INDEX_COUNT TMR_NUMBER_OF_MODULES
 // *****************************************************************************
 /* Timer Driver Client Status
   Summary:
     Identifies the client-specific status of the Timer driver
   Description:
     This enumeration identifies the client-specific status of the Timer driver.
   Remarks:
     None.
 */

 typedef
   enum
   {
     /* Driver is invalid (or unopened) state */
     DRV_TMR_CLIENT_STATUS_INVALID
         /*DOM-IGNORE-BEGIN*/
     = DRV_CLIENT_STATUS_ERROR                          /*DOM-IGNORE-END*/
     ,
     /* An operation is currently in progress */
     DRV_TMR_CLIENT_STATUS_BUSY
         /*DOM-IGNORE-BEGIN*/
     = DRV_CLIENT_STATUS_BUSY                          /*DOM-IGNORE-END*/
     ,
     /* Ready, no operations running */
     DRV_TMR_CLIENT_STATUS_READY
         /*DOM-IGNORE-BEGIN*/
     = DRV_CLIENT_STATUS_READY + 0                          /*DOM-IGNORE-END*/
     ,
     /* Timer started and running, processing transactions */
     DRV_TMR_CLIENT_STATUS_RUNNING
         /*DOM-IGNORE-BEGIN*/
     = DRV_CLIENT_STATUS_READY + 1                          /*DOM-IGNORE-END*/
   } DRV_TMR_CLIENT_STATUS ;
 // *****************************************************************************
 /* Timer Driver Clock sources
   Summary:
     Lists the clock sources available for timer driver.
   Description:
     This enumeration lists all the available clock sources for the timer
     hardware.
   Remarks:
     Not all modes are available on all devices.
     'Synchronization' may not be applicable for all the instances of the timer.
     The driver discards the Synchronization mode selected if it is not
     applicable for the selected hardware.
 */
 // *****************************************************************************
 /* Timer Driver Operation mode
   Summary:
     Lists the operation modes available for timer driver.
   Description:
     This enumeration lists all the available operation modes that are valid for
     the timer hardware.
   Remarks:
     Not all modes are available on all devices.
 */

 typedef
   enum
   {
     /* The timer module operating mode none/invalid */
     DRV_TMR_OPERATION_MODE_NONE ,
     /* The timer module operates in 16 bit mode */
     DRV_TMR_OPERATION_MODE_16_BIT ,
     /* The timer module operates in 32 bit mode */
     /* This will combine two 16 bit timer modules */
     DRV_TMR_OPERATION_MODE_32_BIT ,
   } DRV_TMR_OPERATION_MODE ;
 // *****************************************************************************
 /* Timer Driver divider operating specification
   Summary:
     This data structure specifies the divider values that can be obtained by the
     timer module.
   Description:
     This data structure specifies the divider values that can be obtained by the
     timer hardware.
   Remarks:
     None.
 */

 typedef
   struct
   {
     /* The minimum divider value that the timer module can obtain */
     uint32_t dividerMin ;
     /* The maximum divider value that the timer module can obtain */
     uint32_t dividerMax ;
     /* The divider step value, between 2 divider values */
     /* Should be 1 for most timers */
     uint32_t dividerStep ;
   } DRV_TMR_DIVIDER_RANGE ;
 // *****************************************************************************
 /* Timer Driver Initialize Data
   Summary:
     Defines the Timer driver initialization data.
   Description:
     This data type defines data required to initialize the Timer driver.
   Remarks:
     Not all initialization features are available on all devices.
 */

 typedef
   struct
   {
     /* System module initialization. */
     SYS_MODULE_INIT moduleInit ;
     /* Identifies timer hardware module (PLIB-level) ID */
     TMR_MODULE_ID tmrId ;
     /* Clock Source select. */
     DRV_TMR_CLK_SOURCES clockSource ;
     /* Prescaler Selection from the processor enumeration */
     TMR_PRESCALE prescale ;
     /* Interrupt Source for TMR module. If 'DRV_TMR_OPERATION_MODE_32_BIT' flag
        is selected the interrupt will be generated by the 2nd timer of the pair,
        the odd numbered one. */
     INT_SOURCE interruptSource ;
     /* Select 16/32 bit operation mode. 32 bit mode will combine two 16 bit
        timer modules to form a 32 bit one. This is usually only necessary for
        very long delays. */
     DRV_TMR_OPERATION_MODE mode ;
     /* Asynchronous write enable configuration. If true the asynchronous write
        is enabled. For timers that do not support this feature the value is
        ignored */
     bool asyncWriteEnable ;
   } DRV_TMR_INIT ;
 // *****************************************************************************
 /* Timer Driver Callback Function Pointer
   Summary:
     Pointer to a Timer driver callback function data type.
   Description:
     This data type defines a pointer to a Timer driver callback function.
   Remarks:
     Useful only when timer alarm callback support is enabled by defining the
     DRV_TMR_ALARM_ENABLE configuration option.
 */

 typedef
 void ( * DRV_TMR_CALLBACK ) ( uintptr_t context ,
 uint32_t alarmCount ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: Timer Driver Module Interface Functions
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Function:
     SYS_MODULE_OBJ DRV_TMR_Initialize
     (
         const SYS_MODULE_INDEX drvIndex,
         const SYS_MODULE_INIT * const init
     )
   Summary:
     Initializes the Timer driver.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This function initializes the Timer driver, making it ready for clients to
     open and use it.
   Precondition:
     None.
   Parameters:
     drvIndex - Index for the driver instance to be initialized
     init - Pointer to a data structure containing any data necessary
                       to initialize the driver.
   Returns:
     If successful, returns a valid handle to a driver object. Otherwise, it
     returns SYS_MODULE_OBJ_INVALID. The returned object must be passed as
     argument to DRV_TMR_Deinitialize, DRV_TMR_Tasks and DRV_TMR_Status functions.
   Example:
     <code>
     DRV_TMR_INIT init;
     SYS_MODULE_OBJ objectHandle;
     // Populate the timer initialization structure
     init.moduleInit.value = SYS_MODULE_POWER_RUN_FULL;
     init.tmrId = TMR_ID_2;
     init.clockSource = DRV_TMR_CLKSOURCE_INTERNAL;
     init.prescale = TMR_PRESCALE_VALUE_256;
     init.interruptSource = INT_SOURCE_TIMER_2;
     init.mode = DRV_TMR_OPERATION_MODE_16_BIT;
     init.asyncWriteEnable = false;
     // Do something
     objectHandle = DRV_TMR_Initialize ( DRV_TMR_INDEX_0, (SYS_MODULE_INIT*)&init );
     if ( SYS_MODULE_OBJ_INVALID == objectHandle )
     {
         // Handle error
     }
     </code>
   Remarks:
     This function must be called before any other Timer driver function is
     called.
     This function should only be called once during system initialization unless
     DRV_TMR_Deinitialize is called to deinitialize the driver instance.
     This function will NEVER block for hardware access. The system must use
     DRV_TMR_Status to find out when the driver is in the ready state.
     Build configuration options may be used to statically override options in
     the "init" structure and will take precedence over initialization data
     passed using this function.
 */

 SYS_MODULE_OBJ
   DRV_TMR_Initialize (
   const SYS_MODULE_INDEX drvIndex ,
   const SYS_MODULE_INIT * const init ) ;
 // *****************************************************************************
 /* Function:
     void DRV_TMR_Deinitialize ( SYS_MODULE_OBJ object )
   Summary:
     Deinitializes the specified instance of the Timer driver.
     <p><b>Implementation:</b> Dynamic</p>
   Description:
     Deinitializes the specified instance of the Timer driver, disabling
     its operation (and any hardware). All internal data is invalidated.
   Precondition:
     The DRV_TMR_Initialize function must have been called before calling this
     function and a valid SYS_MODULE_OBJ must have been returned.
   Parameters:
     object - Driver object handle, returned from DRV_TMR_Initialize
   Returns:
     None.
   Example:
     <code>
     SYS_MODULE_OBJ tmrObject; // Returned from DRV_TMR_Initialize
     SYS_STATUS tmrStatus;
     DRV_TMR_Deinitialize ( tmrObject );
     tmrStatus = DRV_TMR_Status ( tmrObject );
     if ( SYS_MODULE_UNINITIALIZED == tmrStatus )
     {
         // Check again later if you need to know
         // when the driver is deinitialized.
     }
     </code>
   Remarks:
     Once the Initialize operation has been called, the Deinitialize operation
     must be called before the Initialize operation can be called again.
     This function will NEVER block waiting for hardware. If the operation
     requires time to allow the hardware to complete, this will be reported by
     the DRV_TMR_Status operation. The system has to use DRV_TMR_Status to find
     out when the module is in the ready state.
 */

 void
   DRV_TMR_Deinitialize (
   SYS_MODULE_OBJ object ) ;
 // *****************************************************************************
 /* Function:
     SYS_STATUS DRV_TMR_Status ( SYS_MODULE_OBJ object )
   Summary:
     Provides the current status of the Timer driver.
     <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function provides the current status of the Timer driver.
   Precondition:
     The DRV_TMR_Initialize function must have been called before calling this
     function.
   Parameters:
     object - Driver object handle, returned from DRV_TMR_Initialize
   Returns:
     SYS_STATUS_READY - Indicates that the driver is initialized and ready
                                 for operation
                                 Note: Any value greater than SYS_STATUS_READY is
                                 also a normal running state in which the driver
                                 is ready to accept new operations.
     SYS_STATUS_ERROR - Indicates that the driver is in an error state
                                 Note: Any value less than SYS_STATUS_ERROR is
                                 also an error state.
     SYS_MODULE_UNINITIALIZED - Indicates that the driver has been deinitialized
                                 Note: This value is less than SYS_STATUS_ERROR.
   Example:
     <code>
     SYS_MODULE_OBJ object; // Returned from DRV_TMR_Initialize
     SYS_STATUS tmrStatus;
     tmrStatus = DRV_TMR_Status ( object );
     else if ( SYS_STATUS_ERROR >= tmrStatus )
     {
         // Handle error
     }
     </code>
   Remarks:
     The this operation can be used to determine when any of the driver's module
     level operations has completed.
         Once the status operation returns SYS_STATUS_READY, the driver is ready for
         operation.
     The value of SYS_STATUS_ERROR is negative (-1). Any value less than that is
     also an error state.
     This function will NEVER block waiting for hardware.
 */

 SYS_STATUS
   DRV_TMR_Status (
   SYS_MODULE_OBJ object ) ;
 // *****************************************************************************
 /* Function:
     void DRV_TMR_Tasks ( SYS_MODULE_OBJ object )
   Summary:
     Maintains the driver's state machine.
     <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function is used to maintain the driver's internal state machine and
     processes the timer events..
   Precondition:
     The DRV_TMR_Initialize function must have been called for the specified Timer
     driver instance.
   Parameters:
     object - Object handle for the specified driver instance (returned from
                   DRV_TMR_Initialize)
   Returns:
     None
   Example:
     <code>
     SYS_MODULE_OBJ object; // Returned from DRV_TMR_Initialize
     while (true)
     {
         DRV_TMR_Tasks ( object );
         // Do other tasks
     }
     </code>
   Remarks:
     This function is normally not called directly by an application. It is
     called by the system's Tasks routine (SYS_Tasks)
 */

 void
   DRV_TMR_Tasks (
   SYS_MODULE_OBJ object ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: TMR Driver Client Functions
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Function:
     DRV_HANDLE DRV_TMR_Open
     (
         const SYS_MODULE_INDEX index,
         const DRV_IO_INTENT intent
     )
   Summary:
     Opens the specified Timer driver instance and returns a handle to it.
     <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function opens the specified Timer driver instance and provides a
     handle that must be provided to all other client-level operations to
     identify the caller and the instance of the driver. Timer driver does not
     support multiple clients. If two tasks want to use the timer, one should
     wait until the other one gets closed.
   Precondition:
     The DRV_TMR_Initialize function must have been called before calling this
     function.
   Parameters:
     index - Identifier for the object instance to be opened
     intent - Zero or more of the values from the enumeration
                   DRV_IO_INTENT ORed together to indicate the intended use
                   of the driver
   Returns:
     If successful, the function returns a valid open instance handle (a number
     identifying both the caller and the module instance).
     If an error occurs, the return value is DRV_HANDLE_INVALID.
   Example:
     <code>
     DRV_HANDLE handle;
     handle = DRV_TMR_Open ( DRV_TMR_INDEX_0, DRV_IO_INTENT_EXCLUSIVE );
     if ( DRV_HANDLE_INVALID == handle )
     {
         // Unable to open the driver
     }
     </code>
   Remarks:
     The handle returned is valid until the DRV_TMR_Close function is called.
     This function will NEVER block waiting for hardware.
     If the requested intent flags are not supported, the function will return
     DRV_HANDLE_INVALID.
     The Timer driver does not support DRV_IO_INTENT_SHARED.
     Only exclusive access is supported for now.
 */

 DRV_HANDLE
   DRV_TMR_Open (
   const SYS_MODULE_INDEX index ,
   const DRV_IO_INTENT intent ) ;
 // *****************************************************************************
 /* Function:
     void DRV_TMR_Close ( DRV_HANDLE handle )
   Summary:
     Closes an opened instance of the Timer driver.
     <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function closes an opened instance of the Timer driver, invalidating
     the handle.
   Precondition:
     The DRV_TMR_Initialize function must have been called for the specified
     Timer driver instance.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
   Returns:
     None
   Example:
     <code>
     DRV_HANDLE handle; // Returned from DRV_TMR_Open
     DRV_TMR_Close ( handle );
     </code>
   Remarks:
     After calling this function, the handle passed in "handle" must not be used
     with any of the remaining driver functions. A new handle must be obtained
     by calling DRV_TMR_Open before the caller may use the driver again.
     Note: Usually there is no need for the driver client to verify that the Close
     operation has completed.
 */

 void
   DRV_TMR_Close (
   DRV_HANDLE handle ) ;
 // *****************************************************************************
 /* Function:
     DRV_TMR_CLIENT_STATUS DRV_TMR_ClientStatus ( DRV_HANDLE handle )
   Summary:
     Gets the status of the client operation.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function gets the status of the recently completed client level
     operation.
   Precondition:
     The DRV_TMR_Initialize function must have been called for the specified
     Timer driver instance.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
   Returns:
     None
   Example:
     <code>
     DRV_HANDLE tmrHandle; // Returned from DRV_TMR_Open
     DRV_TMR_CLIENT_STATUS tmrDrvStatus;
     tmrDrvStatus = DRV_TMR_ClientStatus ( tmrHandle );
     </code>
   Remarks:
     None.
 */

 DRV_TMR_CLIENT_STATUS
   DRV_TMR_ClientStatus (
   DRV_HANDLE handle ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: TMR Driver Counting functions
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Function:
     void DRV_TMR_CounterValueSet ( DRV_HANDLE handle, uint32_t counterPeriod )
   Summary:
     Updates the Timer's counter register.
         <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This function updates the Timer's value in the counter register.
   Precondition:
     The DRV_TMR_Initialize function must have been called.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
              open routine
     counterPeriod - counter period value
                       - a 16 bit value if the timer is configured in 16 bit mode
                       - a 32 bit value if the timer is configured in 32 bit mode
   Returns:
     None.
   Example:
     <code>
     </code>
   Remarks:
     None.
 */

 void
   DRV_TMR_CounterValueSet (
   DRV_HANDLE handle ,
   uint32_t counterPeriod ) ;
 // *****************************************************************************
 /* Function:
     uint32_t DRV_TMR_CounterValueGet ( DRV_HANDLE handle )
   Summary:
     Reads the Timer's counter register.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This function returns the Timer's value in the counter register.
   Precondition:
     The DRV_TMR_Initialize function must have been called.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle      - A valid open-instance handle, returned from the driver's
                         open routine
   Returns:
     Timer current period:
                       - a 16 bit value if the timer is configured in 16 bit mode
                       - a 32 bit value if the timer is configured in 32 bit mode
   Example:
     <code>
     //Example to use timer for precision time measurement
     //without configuring an alarm (interrupt based)
     char appState = 0;
     DRV_HANDLE tmrHandle; // Returned from DRV_TMR_Open
     switch ( appState )
     {
         case 0:
             //Calculate and set the counter period
             DRV_TMR_CounterValueSet ( tmrHandle, ( 0xFFFF - 0x1000 ) );
             //counter starts
             DRV_TMR_Start ( tmrHandle );
             //Trigger an application operation
             app_trigger_operation();
             //Check for time-out in the next state
             appState++;
         case 1:
             //Overflows and stops at 0 if no alarm is set
             if ( DRV_TMR_CounterValueGet ( tmrHandle ) == 0 )
             {
                 //Time-out
                 return false;
             }
             else if ( app_operation_isComplete( ) )
             {
                 //Operation is complete before time-out
                 return true;
             }
     </code>
   Remarks:
     None.
 */

 uint32_t
   DRV_TMR_CounterValueGet (
   DRV_HANDLE handle ) ;
 // *****************************************************************************
 /* Function:
     void DRV_TMR_CounterClear ( DRV_HANDLE handle )
   Summary:
     Clears the Timer's counter register.
         <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This function clears the Timer's value in the counter register.
   Precondition:
     The DRV_TMR_Initialize function must have been called.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
              open routine
   Returns:
     None.
   Example:
     <code>
         </code>
   Remarks:
     None.
 */

 void
   DRV_TMR_CounterClear (
   DRV_HANDLE handle ) ;
 // *****************************************************************************
 /* Function:
     bool DRV_TMR_AlarmRegister
     (
         DRV_HANDLE handle,
         uint32_t divider,
         bool isPeriodic,
         uintptr_t context,
         DRV_TMR_CALLBACK callBack
     )
   Summary:
     Sets up an alarm.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function sets up an alarm, allowing the client to receive a callback
     from the driver when the timer counter reaches zero. Alarms can be one-shot
     or periodic. A periodic alarm will reload the timer and generate alarm
     until stopped. The alarm frequency is: DRV_TMR_CounterFrequencyGet() /
     divider;
   Precondition:
     The DRV_TMR_Initialize function must have been called.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
     divider value has to be within the timer divider range (see DRV_TMR_DividerSpecGet).
   Parameters:
     handle - A valid handle, returned from DRV_TMR_Open
     divider - The value to divide the timer clock source to obtain the
                   required alarm frequency.
                 - a 16 bit value if the timer is configured in 16 bit mode
                 - a 32 bit value if the timer is configured in 32 bit mode
         isPeriodic - Flag indicating whether the alarm should be one-shot or periodic.
         context - A reference, call back function will be called with the same
             reference.
         callBack - A call back function which will be called on time out.
   Returns:
     - true - if the call succeeded
     - false - the obtained divider could not be obtained or the passed handle was invalid
   Example:
     <code>
     //Do the initialization with 'mode' set to DRV_TMR_OPERATION_MODE_16_BIT
         void setupTask ()
         {
          DRV_HANDLE tmrHandle; // Returned from DRV_TMR_Open
         uint32_t myFreq = 1000; // 1KHz
         uint32_t clkFreq = DRV_TMR_CounterFrequencyGet(tmrHandle); // timer running frequency
         // calculate the divider needed
         uint32_t divider = clkFreq / myFreq;
          // Start the alarm
          if(!DRV_TMR_AlarmRegister ( tmrHandle, divider, true, 0, CallBackFreq ))
         {
             // divider value could not be obtain;
             // handle the error
             //
         }
     }
     </code>
   Remarks:
     The divider value will be truncated to a 16 bit value if the timer is
     configured in 16 bit mode. The timer should be started using DRV_TMR_Start API to get a
         callback.
 */

 bool
   DRV_TMR_AlarmRegister (
   DRV_HANDLE handle ,
   uint32_t divider ,
   bool isPeriodic ,
   uintptr_t context ,
   DRV_TMR_CALLBACK callBack ) ;
 // *****************************************************************************
 /* Function:
     bool DRV_TMR_AlarmDisable ( DRV_HANDLE handle);
   Summary:
     Disables an alarm signal.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function allows the client to disable an alarm generation.
     Use DRV_TMR_AlarmEnable to re-enable.
   Precondition:
     The DRV_TMR_Initialize function must have been called.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
     A client alarm must be active.
   Parameters:
     handle - A valid handle, returned from DRV_TMR_Open
   Returns:
     The current status of the alarm:
     - true if the alarm was currently enabled
     - false if the alarm was currently disabled
   Example:
     <code>
     </code>
   Remarks:
     When the driver operates in interrupts this call resolves to a device
     interrupt disable.
     Do NOT disable the timer except for very short periods of time. If the time
     that the interrupt is disabled is longer than a wrap around period and the
     interrupt is missed, the hardware has no means of recovering and the
     resulting timing will be inaccurate.
 */

 bool
   DRV_TMR_AlarmDisable (
   DRV_HANDLE handle ) ;
 // *****************************************************************************
 /* Function:
     void DRV_TMR_AlarmEnable ( DRV_HANDLE handle, bool enable );
   Summary:
     Re-enables an alarm signal.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function allows the client to re-enable an alarm after it has been
     disabled by a DRV_TMR_AlarmDisable call.
   Precondition:
     The DRV_TMR_Initialize function must have been called.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid handle, returned from DRV_TMR_Open
     enable - boolean to enable the current callback
   Returns:
     None
   Example:
     <code>
     </code>
   Remarks:
     When the driver operates in interrupts this call resolves to a device
     interrupt re-enable.
 */

 void
   DRV_TMR_AlarmEnable (
   DRV_HANDLE handle ,
   bool enable ) ;
 // *****************************************************************************
 /* Function:
     void DRV_TMR_AlarmPeriodSet ( DRV_HANDLE handle, uint32_t value )
   Summary:
     Updates the Timer's period.
     <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function updates the Timer's period.
   Precondition:
     The DRV_TMR_Initialize function must have been called.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
     value - Period value
                       - a 16 bit value if the timer is configured in 16 bit mode
                       - a 32 bit value if the timer is configured in 32 bit mode
   Returns:
     None.
   Example:
     <code>
     DRV_HANDLE handle; // Returned from DRV_TMR_Open
     DRV_TMR_AlarmPeriodSet ( handle, 0x1000 );
     </code>
   Remarks:
     - The period value will be truncated to a 16 bit value if the timer is
     configured in 16 bit mode.
 */

 void
   DRV_TMR_AlarmPeriodSet (
   DRV_HANDLE handle ,
   uint32_t value ) ;
 // *****************************************************************************
 /* Function:
     uint32_t DRV_TMR_AlarmPeriodGet ( DRV_HANDLE handle )
   Summary:
     Provides the Timer's period.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function gets the Timer's period.
   Precondition:
     The DRV_TMR_Initialize function must have been called.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
   Returns:
     Timer period value:
                       - a 16 bit value if the timer is configured in 16 bit mode
                       - a 32 bit value if the timer is configured in 32 bit mode
   Example:
     <code>
     DRV_HANDLE tmrHandle; // Returned from DRV_TMR_Open
     uint32_t period;
     period = DRV_TMR_AlarmPeriodGet ( tmrHandle );
     </code>
   Remarks:
     None.
 */

 uint32_t
   DRV_TMR_AlarmPeriodGet (
   DRV_HANDLE handle ) ;
 // *****************************************************************************
 /* Function:
     void DRV_TMR_AlarmDeregister ( DRV_HANDLE handle )
   Summary:
     Removes a previously set alarm.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function removes a previously set alarm.
   Precondition:
     The DRV_TMR_Initialize function must have been called.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
         DRV_TMR_AlarmRegister function must have been called before.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
   Returns:
     None.
   Example:
     <code>
     // Example of a key debounce check
     static unsigned int lastReadKey, readKey, keyCount, globalKeyState;
     DRV_HANDLE tmrHandle; // Returned from DRV_TMR_Open
     void keyPressDetect ()
     {
         // Calculate the count to be passed on from the clock input
         DRV_TMR_AlarmRegister ( tmrHandle, 0xFF00, true, DebounceCheck );
     }
     void DebounceCheck ( uintptr_t context )
     {
         readKey = AppReadKey();
         if ( readKey != lastReadKey )
         {
             lastReadKey = readKey;
             keyCount = 0;
         }
         else
         {
             if ( keyCount > 20 )
             {
                 globalKeyState = readKey;
                 DRV_TMR_AlarmDeregister ( tmrHandle );
             }
             keyCount++;
         }
     }
     </code>
   Remarks:
     None.
 */

 void
   DRV_TMR_AlarmDeregister (
   DRV_HANDLE handle ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: TMR Driver Operation Control Functions
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Function:
     bool DRV_TMR_Start ( DRV_HANDLE handle )
   Summary:
     Starts the Timer counting.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This function starts the Timer counting.
   Precondition:
     The DRV_TMR_Initialize function must have been called.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
     Timer parameters must have been set by a call to DRV_TMR_AlarmRegister.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
   Returns:
     - true - if the operation succeeded
     - false - the supplied handle is invalid or the client doesn't have
                   the needed parameters to run (alarm callback and period )
   Example:
     <code>
     DRV_HANDLE tmrHandle; // Returned from DRV_TMR_Open
     DRV_TMR_AlarmRegister(tmrHandle, 0x100, true, 0, myTmrCallback);
     DRV_TMR_Start ( tmrHandle );
     </code>
   Remarks:
     None.
 */

 bool
   DRV_TMR_Start (
   DRV_HANDLE handle ) ;
 // *****************************************************************************
 /* Function:
     void DRV_TMR_Stop ( DRV_HANDLE handle )
   Summary:
     Stops the Timer from counting.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This function stops the running Timer from counting.
   Precondition:
     The DRV_TMR_Initialize function must have been called.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
   Returns:
     None.
   Example:
     <code>
     DRV_HANDLE handle; // Returned from DRV_TMR_Open
     DRV_TMR_Stop ( handle );
     </code>
   Remarks:
     None.
 */

 void
   DRV_TMR_Stop (
   DRV_HANDLE handle ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: TMR Driver Operation Status Functions
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Function:
     unsigned int DRV_TMR_AlarmHasElapsed ( DRV_HANDLE handle )
   Summary:
     Provides the status of Timer's period elapse.
     <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function returns the number of times Timer's period has elapsed since
     last call to this API has made. On calling this API, the internally
     maintained counter will be cleared and count will be started again from next
     elapse.
   Precondition:
     The DRV_TMR_Initialize function must have been called.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid handle, returned from the DRV_TMR_Open
   Returns:
     Number of times timer has elapsed since the last call.
   Example:
     <code>
     DRV_HANDLE tmrHandle; // Returned from DRV_TMR_Open
     bool elapseStatus;
         SYS_MODULE_OBJ tmrObject // Returned by DRV_TMR_Initialize
         unsigned int appInternalTime = 0;
     Sys_Tasks()
         {
          //Timer task will be called from ISR
          APP_TimeUpdate_Task();
          //Other Tasks
         }
         void APP_TimeUpdate_Task ( void )
         {
          //We will not miss a count even though we are late
          appInternalTime += DRV_TMR_AlarmHasElapsed ( tmrHandle );
         }
     </code>
   Remarks:
     None.
 */

 uint32_t
   DRV_TMR_AlarmHasElapsed (
   DRV_HANDLE handle ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: TMR Driver Control and Information Functions
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Function:
     bool DRV_TMR_ClockSet
     (
         DRV_HANDLE handle,
         DRV_TMR_CLK_SOURCES clockSource,
          TMR_PRESCALE preScale
     )
   Summary:
     Sets the timers clock by selecting the source and prescaler.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function sets the timer clock by selecting the source and prescaler.
     The clock sources are device specific, refer device datasheet for supported
     clock sources. If unsupported clock source is passed then the behaviour of
     this function is unpredictable.
   Precondition:
     The DRV_TMR_Initialize function must have been called. Must have selected
         32-Bit timer mode if mode selection is applicable.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
     clockSource - Clock source of the timer
     preScale - Timer's Prescaler divisor
   Returns:
     - true - if the operation is successful
     - false - either the handle is invalid or the clockSource
                   and/or prescaler are not supported
   Example:
     <code>
         DRV_HANDLE tmrHandle; // Returned from DRV_TMR_Open
         DRV_TMR_ClockSet ( tmrHandle, DRV_TMR_CLKSOURCE_INTERNAL, TMR_PRESCALE_VALUE_256 );
     </code>
   Remarks:
     None.
 */

 bool
   DRV_TMR_ClockSet (
   DRV_HANDLE handle ,
   DRV_TMR_CLK_SOURCES clockSource ,
   TMR_PRESCALE preScale ) ;
 // *****************************************************************************
 /* Function:
     TMR_PRESCALE DRV_TMR_PrescalerGet ( DRV_HANDLE handle )
   Summary:
     This function gets the currently selected prescaler.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function gets the currently selected prescaler.
   Precondition:
     The DRV_TMR_Initialize function must have been called.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
   Returns:
     Timer prescaler.
   Example:
     <code>
     DRV_HANDLE tmrHandle; // Returned from DRV_TMR_Open
     TMR_PRESCALE preScale;
     preScale = DRV_TMR_PrescalerGet ( tmrHandle );
     </code>
   Remarks:
     None.
 */

 TMR_PRESCALE
   DRV_TMR_PrescalerGet (
   DRV_HANDLE handle ) ;
 // *****************************************************************************
 /* Function:
     DRV_TMR_OPERATION_MODE DRV_TMR_OperationModeGet(DRV_HANDLE handle)
   Summary:
     This function gets the currently selected operation mode.
     <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function gets the currently selected 16/32 bit operation mode.
   Precondition:
     The DRV_TMR_Initialize function must have been called.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
   Returns:
     A DRV_TMR_OPERATION_MODE value showing how the timer is currently
     configured. DRV_TMR_OPERATION_MODE_NONE is returned for an invalid client
     handle.
   Example:
     <code>
     DRV_HANDLE tmrHandle; // Returned from DRV_TMR_Open
         DRV_TMR_OPERATION_MODE operMode;
         operMode = DRV_TMR_OperationModeGet ( tmrHandle );
     </code>
   Remarks:
     None.
 */

 DRV_TMR_OPERATION_MODE
   DRV_TMR_OperationModeGet (
   DRV_HANDLE handle ) ;
 // *****************************************************************************
 /* Function:
     bool DRV_TMR_GateModeSet ( DRV_HANDLE handle )
   Summary:
     Enables the Gate mode.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function enables the Gated mode of Timer. User can measure the duration
     of an external signal in this mode. Once the Gate mode is enabled, Timer
     will start on the raising edge of the external signal. It will keep counting
     until the next falling edge.
   Precondition:
     The DRV_TMR_Initialize function must have been called.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
   Returns:
     - true - if the operation is successful
     - false - either the handle is invalid or the gate mode
                   is not supported
   Example:
     <code>
     DRV_HANDLE tmrHandle; // Returned from DRV_TMR_Open
     DRV_TMR_GateModeSet ( tmrHandle );
     </code>
   Remarks:
     None.
 */

 bool
   DRV_TMR_GateModeSet (
   DRV_HANDLE handle ) ;
 // *****************************************************************************
 /* Function:
     bool DRV_TMR_GateModeClear ( DRV_HANDLE handle )
   Summary:
     Enables the Gate mode.
     <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function enables the Gated mode of Timer. User can measure the duration
     of an external signal in this mode. Once the Gate mode is enabled, Timer
     will start on the raising edge of the external signal. It will keep counting
     until the next falling edge.
   Precondition:
     The DRV_TMR_Initialize function must have been called.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
   Returns:
     - true - if the operation is successful
     - false - either the handle is invalid or the gate mode
                   is not supported
   Example:
     <code>
     DRV_HANDLE tmrHandle; // Returned from DRV_TMR_Open
     DRV_TMR_GateModeClear ( tmrHandle );
     </code>
   Remarks:
     None.
 */

 bool
   DRV_TMR_GateModeClear (
   DRV_HANDLE handle ) ;
 // *****************************************************************************
 /* Function:
     uint32_t DRV_TMR_CounterFrequencyGet ( DRV_HANDLE handle )
   Summary:
     Provides the Timer input frequency.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function provides the Timer input frequency. Input frequency is the
     clock to the Timer register and it is considering the prescaler divisor.
   Precondition:
     The DRV_TMR_Initialize function must have been called.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                   open routine
   Returns:
     32-bit value corresponding to the running frequency.
     If Timer clock source is external, then this function returns 0.
   Example:
     <code>
     DRV_HANDLE tmrHandle; // Returned from DRV_TMR_Open
     uint32_t clkFreqHz;
     clkFreqHz = DRV_TMR_CounterFrequencyGet ( tmrHandle );
     </code>
   Remarks:
     On most processors, the Timer's base frequency is the same as the peripheral
     bus clock.
 */

 uint32_t
   DRV_TMR_CounterFrequencyGet (
   DRV_HANDLE handle ) ;
 // *****************************************************************************
 /* Function:
     DRV_TMR_OPERATION_MODE DRV_TMR_DividerRangeGet
     (
         DRV_HANDLE handle,
         DRV_TMR_DIVIDER_RANGE* pDivRange
     )
   Summary:
     Returns the Timer divider values.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function provides the Timer operating mode and divider range.
   Precondition:
     The DRV_TMR_Initialize function must have been called.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                   open routine
    pDivRange - Address to store the timer divider range.
   Returns:
     - A DRV_TMR_OPERATION_MODE value showing how the timer is currently configured.
       The pDivRange is updated with the supported range values.
     - DRV_TMR_OPERATION_MODE_NONE for invalid client handle
   Example:
     <code>
     DRV_HANDLE tmrHandle; // Returned from DRV_TMR_Open
     DRV_TMR_OPERATION_MODE timerMode;
     DRV_TMR_DIVIDER_RANGE timerRange;
     DRV_TMR_DividerRangeGet(handle, &timerRange);
     uint32_t clkFreqHz = DRV_TMR_CounterFrequencyGet ( tmrHandle );
     uint32_t maxFreqHz = clkFreqHz / timerRange.dividerMin;
     uint32_t minFreqHz = clkFreqHz / timerRange.dividerMax;
     </code>
   Remarks:
     None.
 */

 DRV_TMR_OPERATION_MODE
   DRV_TMR_DividerRangeGet (
   DRV_HANDLE handle ,
   DRV_TMR_DIVIDER_RANGE * pDivRange ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: File includes for the APIs which are required for backward
 // compatibility.
 // *****************************************************************************
 // *****************************************************************************
 /* OPEN FILE C:\microchip\harmony\v2_06\framework\driver\tmr\drv_tmr_compatibility.h */
 /*******************************************************************************
   Timer Device Driver Interface Definition
   Company:
     Microchip Technology Inc.
   File Name:
     drv_tmr_compatibility.h
   Summary:
     Timer device driver interface header file.
   Description:
     This header file contains macro definition for APIs which will be deprecated
         later. This header file is included in drv_tmr.h.
 *******************************************************************************/
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2013-2014 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
 *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _DRV_TMR_DEPRECATED_H
 #define _DRV_TMR_DEPRECATED_H
 // *****************************************************************************
 // *****************************************************************************
 // Section: File includes
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Function:
     void DRV_TMR_Tasks_ISR ( SYS_MODULE_OBJ object )
   Summary:
     Maintains the driver's state machine, processes the events and implements
         its ISR.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function is used to maintain the driver's internal state machine and
     processes the timer events in interrupt-driven implementations
     (DRV_TMR_INTERRUPT_MODE == true).
   Precondition:
     The DRV_TMR_Initialize function must have been called for the specified Timer
     driver instance.
   Parameters:
     object - Object handle for the specified driver instance (returned from
                   DRV_TMR_Initialize)
   Returns:
     None
   Example:
     <code>
         void __ISR(_TIMER_2_VECTOR, ipl4) _InterruptHandler_TMR2(void)
         {
             DRV_TMR_Tasks_ISR(appDrvObjects.drvTmrObject);
         }
     </code>
   Remarks:
     This function is normally not called directly by an application.
     It is called by the timer driver raw ISR.
     This function will execute in an ISR context and will never block or access any
     resources that may cause it to block.

     This function will be deprecated later, so avoid using it as much as possible.
     Use generic function "DRV_TMR_Tasks" instead of this.
 */
 #define DRV_TMR_Tasks_ISR( object ) DRV_TMR_Tasks ( object )
 // *****************************************************************************
 /* Function:
     void DRV_TMR_CounterValue16BitSet
     (
         DRV_HANDLE handle,
         uint16_t counterPeriod
     )
   Summary:
     Updates the 16-bit Timer's counter register.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function updates the 16-bit Timer's value in the counter register. This
     is valid only if the 16-bit mode of the timer is selected('mode' in the INIT
     structure is set to DRV_TMR_OPERATION_MODE_16_BIT). Otherwise use
     DRV_TMR_CounterValue32BitSet function.
   Precondition:
     The DRV_TMR_Initialize function must have been called. Must have selected
     16-Bit timer mode if mode selection is applicable.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
              open routine
     counterPeriod - 16-bit counter period value
   Returns:
     None.
   Example:
     <code>
     //Example to use timer for precision time measurement
         //without configuring an alarm (interrupt based)
         char appState = 0;
         DRV_HANDLE tmrHandle; // Returned from DRV_TMR_Open

         switch ( appState )
         {
          case 0:
           //Calculate and set the counter period
           DRV_TMR_CounterValue16BitSet ( tmrHandle, ( 0xFFFF - 0x1000 ) );

           //counter starts
           DRV_TMR_Start ( tmrHandle );

           //Trigger an application operation
           app_trigger_operation();

           //Check for time-out in the next state
           appState++;
          case 1:
           //Overflows and stops at 0 if no alarm is set
           if ( DRV_TMR_CounterValue16BitGet ( tmrHandle ) == 0 )
           {
            //Time-out
            return false;
           }
           else if ( app_operation_isComplete( ) )
           {
            //Operation is complete before time-out
            return true;
           }
     </code>
   Remarks:
     This function will be deprecated later, so avoid using it as much as possible.
         Use generic function "DRV_TMR_CounterValueSet" instead of this.
 */
 #define DRV_TMR_CounterValue16BitSet( handle , counterPeriod ) DRV_TMR_CounterValueSet ( handle , counterPeriod )
 // *****************************************************************************
 /* Function:
     void DRV_TMR_CounterValue32BitSet
     (
         DRV_HANDLE handle,
         uint32_t counterPeriod
     )
   Summary:
     Updates the 32-bit Timer's counter register.
     <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function updates the 32-bit Timer's value in the counter register. This
     is valid only if the 32-bit mode of the timer is selected Otherwise use
     DRV_TMR_CounterValue16BitSet function.
   Precondition:
     The DRV_TMR_Initialize function must have been called. Must have selected
         32-Bit timer mode.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle      - A valid open-instance handle, returned from the driver's
                         open routine
     counterPeriod - 32-bit counter period value
   Returns:
     None.
   Example:
     <code>
     //Example to use timer for precision time measurement
     //without configuring an alarm (interrupt based)
     char appState = 0;
     DRV_HANDLE tmrHandle; // Returned from DRV_TMR_Open

     switch ( appState )
     {
         case 0:
             //Calculate and set the counter period
             DRV_TMR_CounterValue32BitSet ( tmrHandle, ( 0xFFFFFFFF - 0xFF343100 ) );

             //counter starts
             DRV_TMR_Start ( tmrHandle );

             //Trigger an application operation against which we want to use the time-out
             app_trigger_operation();

             //Check for time-out in the next state
             appState++;
         case 1:
             //Overflows and stops at 0 if no alarm is set
             if ( DRV_TMR_CounterValue32BitGet ( tmrHandle ) == 0 )
             {
                 //Time-out
                 return false;
             }
             else if ( app_operation_isComplete( ) )
             {
                 //Operation is complete before time-out
                 return true;
             }
     </code>
   Remarks:
     In most of the devices only even numbered instances of timer supports
     32-bit mode.
     This function will be deprecated later, so avoid using it as much as possible.
     Use generic function "DRV_TMR_CounterValueSet" instead of this.
 */
 #define DRV_TMR_CounterValue32BitSet( handle , counterPeriod ) DRV_TMR_CounterValueSet ( handle , counterPeriod )
 // *****************************************************************************
 /* Function:
     uint16_t DRV_TMR_CounterValue16BitGet ( DRV_HANDLE handle )
   Summary:
     Reads the 16-bit Timer's counter register.
     <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function returns the 16-bit Timer's value in the counter register. This
         is valid only if the 16-bit mode of the timer is selected.
         Otherwise use DRV_TMR_CounterValue32BitGet function.
   Precondition:
     The DRV_TMR_Initialize function must have been called. Must have selected
         16-Bit timer mode if mode selection is applicable.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle      - A valid open-instance handle, returned from the driver's
                         open routine

   Returns:
     Timer period in 16-bit mode.
   Example:
     <code>
     //Example to use timer for precision time measurement
     //without configuring an alarm (interrupt based)
     char appState = 0;
     DRV_HANDLE tmrHandle; // Returned from DRV_TMR_Open

     switch ( appState )
     {
         case 0:
             //Calculate and set the counter period
             DRV_TMR_CounterValue16BitSet ( tmrHandle, ( 0xFFFF - 0x1000 ) );

             //counter starts
             DRV_TMR_Start ( tmrHandle );

             //Trigger an application operation
             app_trigger_operation();

             //Check for time-out in the next state
             appState++;
         case 1:
             //Overflows and stops at 0 if no alarm is set
             if ( DRV_TMR_CounterValue16BitGet ( tmrHandle ) == 0 )
             {
                 //Time-out
                 return false;
             }
             else if ( app_operation_isComplete( ) )
             {
                 //Operation is complete before time-out
                 return true;
             }
     </code>
   Remarks:
     This function will be deprecated later, so avoid using it as much as possible.
     Use generic function "DRV_TMR_CounterValueGet" instead of this.
 */
 #define DRV_TMR_CounterValue16BitGet( handle ) DRV_TMR_CounterValueGet ( handle )
 // *****************************************************************************
 /* Function:
     uint32_t DRV_TMR_CounterValue32BitGet ( DRV_HANDLE handle )
   Summary:
     Reads the 32-bit Timer's counter register.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function returns the 32-bit Timer's value in the counter register. This
     is valid only if the 32-bit mode of the timer is selected Otherwise use
     DRV_TMR_CounterValue16BitGet function.
   Precondition:
     The DRV_TMR_Initialize function must have been called. Must have selected
     32-Bit timer mode.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
              open routine

   Returns:
     32-Bit Counter value.
   Example:
     <code>
         //Example to use timer for precision time measurement
         //without configuring an alarm (interrupt based)
         char appState = 0;
         DRV_HANDLE tmrHandle; // Returned from DRV_TMR_Open

         switch ( appState )
         {
          case 0:
           //Calculate and set the counter period
           DRV_TMR_CounterValue32BitSet ( tmrHandle, ( 0xFFFFFFFF - 0x23321000 ) );

           //counter starts
           DRV_TMR_Start ( tmrHandle );

           //Trigger an application operation
           app_trigger_operation();

           //Check for time-out in the next state
           appState++;
          case 1:
           //Overflows and stops at 0 if no alarm is set
           if ( DRV_TMR_CounterValue32BitGet ( tmrHandle ) == 0 )
           {
            //Time-out
            return false;
           }
           else if ( app_operation_isComplete( ) )
           {
            //Operation is complete before time-out
            return true;
           }
         </code>
   Remarks:
     In most of the devices only even numbered instances of timer supports
         32-bit mode.
         This function will be deprecated later, so avoid using it as much as possible.
         Use generic function "DRV_TMR_CounterValueGet" instead of this.
 */
 #define DRV_TMR_CounterValue32BitGet( handle ) DRV_TMR_CounterValueGet ( handle )
 // *****************************************************************************
 /* Function:
     void DRV_TMR_Alarm16BitRegister
     (
         DRV_HANDLE handle,
         uint16_t period,
         bool isPeriodic,
         uintptr_t context,
         DRV_TMR_CALLBACK callBack
     )
   Summary:
     Sets up an alarm.
     <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function sets up an alarm, allowing the client to receive a callback
     from the driver when the counter period elapses. Alarms can be one-shot or
     periodic. This API is valid only if the 16-bit mode of the timer is
     selected. Otherwise use DRV_TMR_Alarm32BitRegister function.
   Precondition:
     The DRV_TMR_Initialize function must have been called. Must have selected
     16-Bit timer mode if mode selection is applicable.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid handle, returned from DRV_TMR_Open
     period - 16-bit period which will be loaded into the Timer hardware register.

     isPeriodic - Flag indicating whether the alarm should be one-shot or periodic.

     context - A reference, call back function will be called with the same
                     reference.

     callBack - A call back function which will be called on period elapse.

   Returns:
     None
   Example:
     <code>
     //Do the initialization with 'mode' set to DRV_TMR_OPERATION_MODE_16_BIT

     void setupTask ()
     {
         DRV_HANDLE tmrHandle; // Returned from DRV_TMR_Open

         // Calculate the count to be passed on from the clock input
         //Periodically toggle LED
         DRV_TMR_Alarm16BitRegister ( tmrHandle, 0xFF40, true, 0,
                                         ToggleLedCallBack );
     }

     void ToggleLedCallBack ( uintptr_t context )
     {
         //Toggle
     }
     </code>
   Remarks:
     This function will be deprecated later, so avoid using it as much as possible.
     Use generic function "DRV_TMR_AlarmRegister" instead of this.
 */
 #define DRV_TMR_Alarm16BitRegister( handle , period , isPeriodic , context , callBack ) DRV_TMR_AlarmRegister ( handle , period , isPeriodic , context , callBack )
 // *****************************************************************************
 /* Function:
     void DRV_TMR_Alarm32BitRegister
     (
         DRV_HANDLE handle,
         uint32_t period,
         bool isPeriodic,
         uintptr_t context,
         DRV_TMR_CALLBACK callBack
     )
   Summary:
     Sets up an alarm.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function sets up an alarm, allowing the client to receive a callback
     from the driver when the counter period elapses. Alarms can be one-shot or
     periodic. This API is valid only if the 32-bit mode of the timer is
     selected Otherwise use DRV_TMR_Alarm16BitRegister function.
   Precondition:
     The DRV_TMR_Initialize function must have been called. Must have selected
         32-Bit timer mode.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid handle, returned from DRV_TMR_Open
     period - 32-bit period which will be loaded into the Timer hardware register.

         isPeriodic - Flag indicating whether the alarm should be one-shot or periodic.

         context - A reference, call back function will be called with the same
             reference.

         callBack - A call back function which will be called on period elapse.

   Returns:
     None
   Example:
     <code>
     //Do the initialization with 'mode' set to DRV_TMR_OPERATION_MODE_32_BIT

         void setupTask ()
         {
          DRV_HANDLE tmrHandle; // Returned from DRV_TMR_Open

          // Calculate the count to be passed on from the clock input
          //Periodically toggle LED
          DRV_TMR_Alarm32BitRegister ( tmrHandle, 0xFFFFFF00, true, 0,
                  ToggleLedCallBack );
     }

         void ToggleLedCallBack ( uintptr_t context )
         {
          //Toggle
         }
     </code>
   Remarks:
     In most of the devices only even numbered instances of timer supports
         32-bit mode.
         This function will be deprecated later, so avoid using it as much as possible.
         Use generic function "DRV_TMR_AlarmRegister" instead of this.
 */
 #define DRV_TMR_Alarm32BitRegister( handle , period , isPeriodic , context , callBack ) DRV_TMR_AlarmRegister ( handle , period , isPeriodic , context , callBack )
 // *****************************************************************************
 /* Function:
     void DRV_TMR_AlarmPeriod16BitSet ( DRV_HANDLE handle, uint16_t value )
   Summary:
     Updates the 16-bit Timer's period.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function updates the 16-bit Timer's period. This API is valid only if
     the 16-bit mode of the timer is selected
     Otherwise use DRV_TMR_AlarmPeriod32BitSet function.
   Precondition:
     The DRV_TMR_Initialize function must have been called. Must have selected
     16-Bit timer mode if mode selection is applicable.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
     value - 16-bit Period value
   Returns:
     None.
   Example:
     <code>
     DRV_HANDLE handle; // Returned from DRV_TMR_Open
     DRV_TMR_AlarmPeriod16BitSet ( handle, 0x1000 );
     </code>
   Remarks:
     This function will be deprecated later, so avoid using it as much as possible.
         Use generic function "DRV_TMR_AlarmPeriodSet" instead of this.
 */
 #define DRV_TMR_AlarmPeriod16BitSet( handle , value ) DRV_TMR_AlarmPeriodSet ( handle , value )
 // *****************************************************************************
 /* Function:
     void DRV_TMR_AlarmPeriod32BitSet ( DRV_HANDLE handle, uint32_t period )
   Summary:
     Updates the 32-bit Timer's period.
     <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function updates the 32-bit Timer's period. This API is valid only if
         the 32-bit mode of the timer is selected
         Otherwise use DRV_TMR_AlarmPeriod16BitSet function.
   Precondition:
     The DRV_TMR_Initialize unction must have been called. Must have selected
         32-Bit timer mode.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
     period - 32-bit Period value
   Returns:
     None.
   Example:
     <code>
     DRV_HANDLE handle; // Returned from DRV_TMR_Open
     DRV_TMR_AlarmPeriod32BitSet ( handle, 0xFFFFFF00 );
     </code>
   Remarks:
     In most of the devices only even numbered instances of timer supports
     32-bit mode.
     This function will be deprecated later, so avoid using it as much as possible.
     Use generic function "DRV_TMR_AlarmPeriodSet" instead of this.
 */
 #define DRV_TMR_AlarmPeriod32BitSet( handle , period ) DRV_TMR_AlarmPeriodSet ( handle , period )
 // *****************************************************************************
 /* Function:
     uint16_t DRV_TMR_AlarmPeriod16BitGet ( DRV_HANDLE handle )
   Summary:
     Provides the 16-bit Timer's period.
     <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function gets the 16-bit Timer's period. This API is valid only if
         the 16-bit mode of the timer is selected.
         Otherwise use DRV_TMR_AlarmPeriod32BitGet function.
   Precondition:
     The DRV_TMR_Initialize function must have been called. Must have selected
         16-Bit timer mode if mode selection is applicable.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
   Returns:
     16-bit timer period value
   Example:
     <code>
     DRV_HANDLE tmrHandle; // Returned from DRV_TMR_Open
     uint16_t period;

     period = DRV_TMR_AlarmPeriod16BitGet ( tmrHandle );
     </code>
   Remarks:
     This function will be deprecated later, so avoid using it as much as possible.
     Use generic function "DRV_TMR_AlarmPeriodGet" instead of this.
 */
 #define DRV_TMR_AlarmPeriod16BitGet( handle ) DRV_TMR_AlarmPeriodGet ( handle )
 // *****************************************************************************
 /* Function:
     uint32_t DRV_TMR_AlarmPeriod32BitGet ( DRV_HANDLE handle )
   Summary:
     Provides the 32-bit Timer's period.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function gets the 32-bit Timer's period. This API is valid only if
     the 32-bit mode of the timer is selected
     Otherwise use DRV_TMR_AlarmPeriod16BitGet function.
   Precondition:
     The DRV_TMR_Initialize function must have been called. Must have selected
     32-Bit timer mode.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
   Returns:
     32-bit Timer period value.
   Example:
     <code>
     DRV_HANDLE handle; // Returned from DRV_TMR_Open
     uint32_t period;
     period = DRV_TMR_AlarmPeriod32BitGet ( handle );
     </code>
   Remarks:
     In most of the devices only even numbered instances of timer supports
         32-bit mode.
         This function will be deprecated later, so avoid using it as much as possible.
         Use generic function "DRV_TMR_AlarmPeriodGet" instead of this.
 */
 #define DRV_TMR_AlarmPeriod32BitGet( handle ) DRV_TMR_AlarmPeriodGet ( handle )
 // *****************************************************************************
 /* Function:
     void DRV_TMR_Alarm16BitDeregister ( DRV_HANDLE handle )
   Summary:
     Removes a previously set alarm.
     <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function removes a previously set alarm. This API is valid only if
     the 16-bit mode of the timer is selected
     Otherwise use DRV_TMR_Alarm32BitDeregister function.
   Precondition:
     The DRV_TMR_Initialize function must have been called. Must have selected
     16-Bit timer mode if mode selection is applicable.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.

     DRV_TMR_Alarm16BitRegister function must have been called before.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
   Returns:
     None.
   Example:
     <code>
     //Example of a key debounce check

         static unsigned int lastReadKey, readKey, keyCount, globalKeyState;
         DRV_HANDLE tmrHandle; // Returned from DRV_TMR_Open
         //Do the initialization with 'mode' set to DRV_TMR_OPERATION_MODE_16_BIT

         void keyPressDetect ()
         {
          // Calculate the count to be passed on from the clock input
          //Periodically toggle LED
          DRV_TMR_Alarm16BitRegister ( tmrHandle, 0xFF00, true,
                  DebounceCheck );
     }

         void DebounceCheck ( uintptr_t context )
         {
          readKey = AppReadKey();

          if ( readKey != lastReadKey )
          {
           lastReadKey = readKey;
           keyCount = 0;
          }
          else
          {
           if ( keyCount > 20 )
           {
            globalKeyState = readKey;
            DRV_TMR_Alarm16BitDeregister ( tmrHandle );
           }
           keyCount++;
          }
         }
     </code>
   Remarks:
     This function will be deprecated later, so avoid using it as much as possible.
         Use generic function "DRV_TMR_AlarmDeregister" instead of this.
 */
 #define DRV_TMR_Alarm16BitDeregister( handle ) DRV_TMR_AlarmDeregister ( handle )
 // *****************************************************************************
 /* Function:
     void DRV_TMR_Alarm32BitDeregister ( DRV_HANDLE handle )
   Summary:
     Removes a previously set alarm.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function removes a previously set alarm. This API is valid only if
         the 32-bit mode of the timer is selected
         Otherwise use DRV_TMR_Alarm16BitDeregister function.
   Precondition:
     The DRV_TMR_Initialize function must have been called. Must have selected
         32-Bit timer mode if mode selection is applicable.
     DRV_TMR_Open must have been called to obtain a valid opened device handle.

         DRV_TMR_Alarm32BitRegister function must have been called before.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
   Returns:
     None.
   Example:
     <code>
     //Example of a key debounce check

     static unsigned int lastReadKey, readKey, keyCount, globalKeyState;
     DRV_HANDLE tmrHandle; // Returned from DRV_TMR_Open
     //Do the initialization with 'mode' set to DRV_TMR_OPERATION_MODE_32_BIT

     void keyPressDetect ( void )
     {
         // Calculate the count to be passed on from the clock input
         //Periodically check the key status
         DRV_TMR_Alarm32BitRegister ( tmrHandle, 0xFF0FFD20, true, 0,
                                         DebounceCheck );
     }

     void DebounceCheck ( uintptr_t context )
     {
         readKey = AppReadKey();

         if ( readKey != lastReadKey )
         {
             lastReadKey = readKey;
             keyCount = 0;
         }
         else
         {
             if ( keyCount > 20 )
             {
                 //Key is stable now
                 globalKeyState = readKey;
                 DRV_TMR_Alarm32BitDeregister ( tmrHandle );
             }
             keyCount++;
         }
     }
     </code>
   Remarks:
     In most of the devices only even numbered instances of timer supports
     32-bit mode.
     This function will be deprecated later, so avoid using it as much as possible.
     Use generic function "DRV_TMR_AlarmDeregister" instead of this.
 */
 #define DRV_TMR_Alarm32BitDeregister( handle ) DRV_TMR_AlarmDeregister ( handle )
        // #ifndef _DRV_TMR_DEPRECATED_H
 /*******************************************************************************
  End of File
 */
 #endif /*00 C:\microchip\harmony\v2_06\framework\driver\tmr\drv_tmr_compatibility.h*/
 /*   CLOSE_FILE Include File */

 //DOM-IGNORE-BEGIN
 //DOM-IGNORE-END
        // #ifndef _DRV_TMR_H
 /*******************************************************************************
  End of File
 */
 #endif /*00 C:\microchip\harmony\v2_06\framework\driver\tmr\drv_tmr.h*/
 /*   CLOSE_FILE Include File */

 #include "peripheral/tmr/plib_tmr.h"
 #include "peripheral/int/plib_int.h"
 // maximum divider value for 32 bit operation mode
 #define DRV_TIMER_DIVIDER_MAX_32BIT 0xffffffff
 // minimum divider value for 32 bit operation mode
 #define DRV_TIMER_DIVIDER_MIN_32BIT 0x2
 // maximum divider value for 16 bit operation mode
 #define DRV_TIMER_DIVIDER_MAX_16BIT 0x10000
 // minimum divider value for 16 bit operation mode
 #define DRV_TIMER_DIVIDER_MIN_16BIT 0x2
 // *****************************************************************************
 // *****************************************************************************
 // Section: Interface Headers for Instance 0 for the static driver
 // *****************************************************************************
 // *****************************************************************************

 void
   DRV_TMR0_Initialize ( void ) ;

 bool
   DRV_TMR0_Start ( void ) ;

 void
   DRV_TMR0_Stop ( void ) ;

 static inline void
   DRV_TMR0_DeInitialize ( void )
   {
  int izzqqzz=((int)(bitmapstruct.element0 |= (1 <<  0))); /* 37 */
     DRV_TMR0_Stop () ;
   ((int)(bitmapstruct.element0 |= (1 <<  1))); /* 30 */
     adc_63zqendz                                                                                         (       2 ) ; /* 30 */
   }

 static inline SYS_STATUS
 DRV_TMR0_Status ( void )
 {
  int izzqqzz=((int)(bitmapstruct.element0 |= (1 <<  2))); /* 37 */
         /* Return the status as ready always */
   ((int)(bitmapstruct.element0 |= (1 <<  3))); /* 30 */
     adc_63zqendz                                                                                         (       4 ) ; /* 30 */
   return
   SYS_STATUS_READY ;
 }

 static inline void
   DRV_TMR0_Open ( void )
   {
  int izzqqzz=((int)(bitmapstruct.element0 |= (1 <<  4))); /* 37 */
   ((int)(bitmapstruct.element0 |= (1 <<  5))); /* 30 */
     adc_63zqendz                                                                                         (       6 ) ; /* 30 */
   }

 DRV_TMR_CLIENT_STATUS
   DRV_TMR0_ClientStatus ( void ) ;

 static inline DRV_TMR_OPERATION_MODE
 DRV_TMR0_OperationModeGet ( void )
 {
  int izzqqzz=((int)(bitmapstruct.element0 |= (1 <<  6))); /* 37 */
   ((int)(bitmapstruct.element0 |= (1 <<  7))); /* 30 */
     adc_63zqendz                                                                                         (       8 ) ; /* 30 */
   return
   DRV_TMR_OPERATION_MODE_16_BIT ;
 }

 static inline void
   DRV_TMR0_Close ( void )
   {
  int izzqqzz=((int)(bitmapstruct.element0 |= (1 <<  8))); /* 37 */
     DRV_TMR0_Stop () ;
   ((int)(bitmapstruct.element0 |= (1 <<  9))); /* 30 */
     adc_63zqendz                                                                                         (      10 ) ; /* 30 */
   }

 bool
   DRV_TMR0_ClockSet (
   DRV_TMR_CLK_SOURCES clockSource ,
   TMR_PRESCALE prescale ) ;

 void
   DRV_TMR0_CounterValueSet (
   uint32_t value ) ;

 uint32_t
   DRV_TMR0_CounterValueGet ( void ) ;

 void
   DRV_TMR0_CounterClear ( void ) ;

 TMR_PRESCALE
   DRV_TMR0_PrescalerGet ( void ) ;

 void
   DRV_TMR0_PeriodValueSet (
   uint32_t value ) ;

 uint32_t
   DRV_TMR0_PeriodValueGet ( void ) ;

 void
   DRV_TMR0_StopInIdleDisable ( void ) ;

 void
   DRV_TMR0_StopInIdleEnable ( void ) ;

 static inline void
   DRV_TMR0_Tasks ( void )
   {
  int izzqqzz=((int)(bitmapstruct.element0 |= (1 << 10))); /* 37 */
   ((int)(bitmapstruct.element0 |= (1 << 11))); /* 30 */
     adc_63zqendz                                                                                         (      12 ) ; /* 30 */
   }

 uint32_t
   DRV_TMR0_CounterFrequencyGet ( void ) ;

 DRV_TMR_OPERATION_MODE
   DRV_TMR0_DividerRangeGet (
   DRV_TMR_DIVIDER_RANGE * pDivRange ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: Interface Headers for Instance 1 for the static driver
 // *****************************************************************************
 // *****************************************************************************

 void
   DRV_TMR1_Initialize ( void ) ;

 bool
   DRV_TMR1_Start ( void ) ;

 void
   DRV_TMR1_Stop ( void ) ;

 static inline void
   DRV_TMR1_DeInitialize ( void )
   {
  int izzqqzz=((int)(bitmapstruct.element0 |= (1 << 12))); /* 37 */
     DRV_TMR1_Stop () ;
   ((int)(bitmapstruct.element0 |= (1 << 13))); /* 30 */
     adc_63zqendz                                                                                         (      14 ) ; /* 30 */
   }

 static inline SYS_STATUS
 DRV_TMR1_Status ( void )
 {
  int izzqqzz=((int)(bitmapstruct.element0 |= (1 << 14))); /* 37 */
         /* Return the status as ready always */
   ((int)(bitmapstruct.element0 |= (1 << 15))); /* 30 */
     adc_63zqendz                                                                                         (      16 ) ; /* 30 */
   return
   SYS_STATUS_READY ;
 }

 static inline void
   DRV_TMR1_Open ( void )
   {
  int izzqqzz=((int)(bitmapstruct.element0 |= (1 << 16))); /* 37 */
   ((int)(bitmapstruct.element0 |= (1 << 17))); /* 30 */
     adc_63zqendz                                                                                         (      18 ) ; /* 30 */
   }

 DRV_TMR_CLIENT_STATUS
   DRV_TMR1_ClientStatus ( void ) ;

 static inline DRV_TMR_OPERATION_MODE
 DRV_TMR1_OperationModeGet ( void )
 {
  int izzqqzz=((int)(bitmapstruct.element0 |= (1 << 18))); /* 37 */
   ((int)(bitmapstruct.element0 |= (1 << 19))); /* 30 */
     adc_63zqendz                                                                                         (      20 ) ; /* 30 */
   return
   DRV_TMR_OPERATION_MODE_16_BIT ;
 }

 static inline void
   DRV_TMR1_Close ( void )
   {
  int izzqqzz=((int)(bitmapstruct.element0 |= (1 << 20))); /* 37 */
     DRV_TMR1_Stop () ;
   ((int)(bitmapstruct.element0 |= (1 << 21))); /* 30 */
     adc_63zqendz                                                                                         (      22 ) ; /* 30 */
   }

 bool
   DRV_TMR1_ClockSet (
   DRV_TMR_CLK_SOURCES clockSource ,
   TMR_PRESCALE prescale ) ;

 void
   DRV_TMR1_CounterValueSet (
   uint32_t value ) ;

 uint32_t
   DRV_TMR1_CounterValueGet ( void ) ;

 void
   DRV_TMR1_CounterClear ( void ) ;

 TMR_PRESCALE
   DRV_TMR1_PrescalerGet ( void ) ;

 void
   DRV_TMR1_PeriodValueSet (
   uint32_t value ) ;

 uint32_t
   DRV_TMR1_PeriodValueGet ( void ) ;

 void
   DRV_TMR1_StopInIdleDisable ( void ) ;

 void
   DRV_TMR1_StopInIdleEnable ( void ) ;

 static inline void
   DRV_TMR1_Tasks ( void )
   {
  int izzqqzz=((int)(bitmapstruct.element0 |= (1 << 22))); /* 37 */
   ((int)(bitmapstruct.element0 |= (1 << 23))); /* 30 */
     adc_63zqendz                                                                                         (      24 ) ; /* 30 */
   }

 uint32_t
   DRV_TMR1_CounterFrequencyGet ( void ) ;

 DRV_TMR_OPERATION_MODE
   DRV_TMR1_DividerRangeGet (
   DRV_TMR_DIVIDER_RANGE * pDivRange ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: Interface Headers for Instance 2 for the static driver
 // *****************************************************************************
 // *****************************************************************************

 void
   DRV_TMR2_Initialize ( void ) ;

 bool
   DRV_TMR2_Start ( void ) ;

 void
   DRV_TMR2_Stop ( void ) ;

 static inline void
   DRV_TMR2_DeInitialize ( void )
   {
  int izzqqzz=((int)(bitmapstruct.element0 |= (1 << 24))); /* 37 */
     DRV_TMR2_Stop () ;
   ((int)(bitmapstruct.element0 |= (1 << 25))); /* 30 */
     adc_63zqendz                                                                                         (      26 ) ; /* 30 */
   }

 static inline SYS_STATUS
 DRV_TMR2_Status ( void )
 {
  int izzqqzz=((int)(bitmapstruct.element0 |= (1 << 26))); /* 37 */
         /* Return the status as ready always */
   ((int)(bitmapstruct.element0 |= (1 << 27))); /* 30 */
     adc_63zqendz                                                                                         (      28 ) ; /* 30 */
   return
   SYS_STATUS_READY ;
 }

 static inline void
   DRV_TMR2_Open ( void )
   {
  int izzqqzz=((int)(bitmapstruct.element0 |= (1 << 28))); /* 37 */
   ((int)(bitmapstruct.element0 |= (1 << 29))); /* 30 */
     adc_63zqendz                                                                                         (      30 ) ; /* 30 */
   }

 DRV_TMR_CLIENT_STATUS
   DRV_TMR2_ClientStatus ( void ) ;

 static inline DRV_TMR_OPERATION_MODE
 DRV_TMR2_OperationModeGet ( void )
 {
  int izzqqzz=((int)(bitmapstruct.element0 |= (1 << 30))); /* 37 */
   ((int)(bitmapstruct.element0 |= (1 << 31))); /* 30 */
     adc_63zqendz                                                                                         (      32 ) ; /* 30 */
   return
   DRV_TMR_OPERATION_MODE_16_BIT ;
 }

 static inline void
   DRV_TMR2_Close ( void )
   {
  int izzqqzz=((int)(bitmapstruct.element1 |= (1 <<  0))); /* 37 */
     DRV_TMR2_Stop () ;
   ((int)(bitmapstruct.element1 |= (1 <<  1))); /* 30 */
     adc_63zqendz                                                                                         (      34 ) ; /* 30 */
   }

 bool
   DRV_TMR2_ClockSet (
   DRV_TMR_CLK_SOURCES clockSource ,
   TMR_PRESCALE prescale ) ;

 void
   DRV_TMR2_CounterValueSet (
   uint32_t value ) ;

 uint32_t
   DRV_TMR2_CounterValueGet ( void ) ;

 void
   DRV_TMR2_CounterClear ( void ) ;

 TMR_PRESCALE
   DRV_TMR2_PrescalerGet ( void ) ;

 void
   DRV_TMR2_PeriodValueSet (
   uint32_t value ) ;

 uint32_t
   DRV_TMR2_PeriodValueGet ( void ) ;

 void
   DRV_TMR2_StopInIdleDisable ( void ) ;

 void
   DRV_TMR2_StopInIdleEnable ( void ) ;

 static inline void
   DRV_TMR2_Tasks ( void )
   {
  int izzqqzz=((int)(bitmapstruct.element1 |= (1 <<  2))); /* 37 */
   ((int)(bitmapstruct.element1 |= (1 <<  3))); /* 30 */
     adc_63zqendz                                                                                         (      36 ) ; /* 30 */
   }

 uint32_t
   DRV_TMR2_CounterFrequencyGet ( void ) ;

 DRV_TMR_OPERATION_MODE
   DRV_TMR2_DividerRangeGet (
   DRV_TMR_DIVIDER_RANGE * pDivRange ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: Interface Headers for Instance 3 for the static driver
 // *****************************************************************************
 // *****************************************************************************

 void
   DRV_TMR3_Initialize ( void ) ;

 bool
   DRV_TMR3_Start ( void ) ;

 void
   DRV_TMR3_Stop ( void ) ;

 static inline void
   DRV_TMR3_DeInitialize ( void )
   {
  int izzqqzz=((int)(bitmapstruct.element1 |= (1 <<  4))); /* 37 */
     DRV_TMR3_Stop () ;
   ((int)(bitmapstruct.element1 |= (1 <<  5))); /* 30 */
     adc_63zqendz                                                                                         (      38 ) ; /* 30 */
   }

 static inline SYS_STATUS
 DRV_TMR3_Status ( void )
 {
  int izzqqzz=((int)(bitmapstruct.element1 |= (1 <<  6))); /* 37 */
         /* Return the status as ready always */
   ((int)(bitmapstruct.element1 |= (1 <<  7))); /* 30 */
     adc_63zqendz                                                                                         (      40 ) ; /* 30 */
   return
   SYS_STATUS_READY ;
 }

 static inline void
   DRV_TMR3_Open ( void )
   {
  int izzqqzz=((int)(bitmapstruct.element1 |= (1 <<  8))); /* 37 */
   ((int)(bitmapstruct.element1 |= (1 <<  9))); /* 30 */
     adc_63zqendz                                                                                         (      42 ) ; /* 30 */
   }

 DRV_TMR_CLIENT_STATUS
   DRV_TMR3_ClientStatus ( void ) ;

 static inline DRV_TMR_OPERATION_MODE
 DRV_TMR3_OperationModeGet ( void )
 {
  int izzqqzz=((int)(bitmapstruct.element1 |= (1 << 10))); /* 37 */
   ((int)(bitmapstruct.element1 |= (1 << 11))); /* 30 */
     adc_63zqendz                                                                                         (      44 ) ; /* 30 */
   return
   DRV_TMR_OPERATION_MODE_16_BIT ;
 }

 static inline void
   DRV_TMR3_Close ( void )
   {
  int izzqqzz=((int)(bitmapstruct.element1 |= (1 << 12))); /* 37 */
     DRV_TMR3_Stop () ;
   ((int)(bitmapstruct.element1 |= (1 << 13))); /* 30 */
     adc_63zqendz                                                                                         (      46 ) ; /* 30 */
   }

 bool
   DRV_TMR3_ClockSet (
   DRV_TMR_CLK_SOURCES clockSource ,
   TMR_PRESCALE prescale ) ;

 void
   DRV_TMR3_CounterValueSet (
   uint32_t value ) ;

 uint32_t
   DRV_TMR3_CounterValueGet ( void ) ;

 void
   DRV_TMR3_CounterClear ( void ) ;

 TMR_PRESCALE
   DRV_TMR3_PrescalerGet ( void ) ;

 void
   DRV_TMR3_PeriodValueSet (
   uint32_t value ) ;

 uint32_t
   DRV_TMR3_PeriodValueGet ( void ) ;

 void
   DRV_TMR3_StopInIdleDisable ( void ) ;

 void
   DRV_TMR3_StopInIdleEnable ( void ) ;

 static inline void
   DRV_TMR3_Tasks ( void )
   {
  int izzqqzz=((int)(bitmapstruct.element1 |= (1 << 14))); /* 37 */
   ((int)(bitmapstruct.element1 |= (1 << 15))); /* 30 */
     adc_63zqendz                                                                                         (      48 ) ; /* 30 */
   }

 uint32_t
   DRV_TMR3_CounterFrequencyGet ( void ) ;

 DRV_TMR_OPERATION_MODE
   DRV_TMR3_DividerRangeGet (
   DRV_TMR_DIVIDER_RANGE * pDivRange ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: Interface Headers for Instance 4 for the static driver
 // *****************************************************************************
 // *****************************************************************************

 void
   DRV_TMR4_Initialize ( void ) ;

 bool
   DRV_TMR4_Start ( void ) ;

 void
   DRV_TMR4_Stop ( void ) ;

 static inline void
   DRV_TMR4_DeInitialize ( void )
   {
  int izzqqzz=((int)(bitmapstruct.element1 |= (1 << 16))); /* 37 */
     DRV_TMR4_Stop () ;
   ((int)(bitmapstruct.element1 |= (1 << 17))); /* 30 */
     adc_63zqendz                                                                                         (      50 ) ; /* 30 */
   }

 static inline SYS_STATUS
 DRV_TMR4_Status ( void )
 {
  int izzqqzz=((int)(bitmapstruct.element1 |= (1 << 18))); /* 37 */
         /* Return the status as ready always */
   ((int)(bitmapstruct.element1 |= (1 << 19))); /* 30 */
     adc_63zqendz                                                                                         (      52 ) ; /* 30 */
   return
   SYS_STATUS_READY ;
 }

 static inline void
   DRV_TMR4_Open ( void )
   {
  int izzqqzz=((int)(bitmapstruct.element1 |= (1 << 20))); /* 37 */
   ((int)(bitmapstruct.element1 |= (1 << 21))); /* 30 */
     adc_63zqendz                                                                                         (      54 ) ; /* 30 */
   }

 DRV_TMR_CLIENT_STATUS
   DRV_TMR4_ClientStatus ( void ) ;

 static inline DRV_TMR_OPERATION_MODE
 DRV_TMR4_OperationModeGet ( void )
 {
  int izzqqzz=((int)(bitmapstruct.element1 |= (1 << 22))); /* 37 */
   ((int)(bitmapstruct.element1 |= (1 << 23))); /* 30 */
     adc_63zqendz                                                                                         (      56 ) ; /* 30 */
   return
   DRV_TMR_OPERATION_MODE_16_BIT ;
 }

 static inline void
   DRV_TMR4_Close ( void )
   {
  int izzqqzz=((int)(bitmapstruct.element1 |= (1 << 24))); /* 37 */
     DRV_TMR4_Stop () ;
   ((int)(bitmapstruct.element1 |= (1 << 25))); /* 30 */
     adc_63zqendz                                                                                         (      58 ) ; /* 30 */
   }

 bool
   DRV_TMR4_ClockSet (
   DRV_TMR_CLK_SOURCES clockSource ,
   TMR_PRESCALE prescale ) ;

 void
   DRV_TMR4_CounterValueSet (
   uint32_t value ) ;

 uint32_t
   DRV_TMR4_CounterValueGet ( void ) ;

 void
   DRV_TMR4_CounterClear ( void ) ;

 TMR_PRESCALE
   DRV_TMR4_PrescalerGet ( void ) ;

 void
   DRV_TMR4_PeriodValueSet (
   uint32_t value ) ;

 uint32_t
   DRV_TMR4_PeriodValueGet ( void ) ;

 void
   DRV_TMR4_StopInIdleDisable ( void ) ;

 void
   DRV_TMR4_StopInIdleEnable ( void ) ;

 static inline void
   DRV_TMR4_Tasks ( void )
   {
  int izzqqzz=((int)(bitmapstruct.element1 |= (1 << 26))); /* 37 */
   ((int)(bitmapstruct.element1 |= (1 << 27))); /* 30 */
     adc_63zqendz                                                                                         (      60 ) ; /* 30 */
   }

 uint32_t
   DRV_TMR4_CounterFrequencyGet ( void ) ;

 DRV_TMR_OPERATION_MODE
   DRV_TMR4_DividerRangeGet (
   DRV_TMR_DIVIDER_RANGE * pDivRange ) ;
        // #ifndef _DRV_TMR_STATIC_H
 /*******************************************************************************
  End of File
 */

 #endif /*00 C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\system_config\default\framework\driver\tmr\drv_tmr_static.h*/
 /*   CLOSE_FILE Include File */

 #include "peripheral/int/plib_int.h"
 /* OPEN FILE C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\system_config\default\framework\driver\pmp\drv_pmp_static.h */
 /*******************************************************************************
  PMP Driver Interface Declarations for Static Single Instance Driver
  Company:
  Microchip Technology Inc.
  File Name:
  drv_pmp_static.h
  Summary:
  PMP driver interface declarations for the static single instance driver.
  Description:
  The PMP device driver provides a simple interface to manage the PMP
  modules on Microchip microcontrollers. This file defines the interface
  Declarations for the PMP driver.

  Remarks:
  Static interfaces incorporate the driver instance number within the names
  of the routines, eliminating the need for an object ID or object handle.

  Static single-open interfaces also eliminate the need for the open handle.
 *******************************************************************************/
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2013 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
 *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _DRV_PMP_STATIC_H
 #define _DRV_PMP_STATIC_H
 #include "peripheral/pmp/plib_pmp.h"
 // *****************************************************************************
 // *****************************************************************************
 // Section: Interface Headers for Instance 0 for the static driver
 // *****************************************************************************
 // *****************************************************************************

 void
   DRV_PMP0_Initialize ( void ) ;

 void
   DRV_PMP0_ModeConfig ( void ) ;

 void
   DRV_PMP0_TimingSet (
   PMP_DATA_WAIT_STATES dataWait ,
   PMP_STROBE_WAIT_STATES strobeWait ,
   PMP_DATA_HOLD_STATES dataHold ) ;

 uint8_t
   DRV_PMP0_Read ( void ) ;

 void
   DRV_PMP0_Write (
   uint8_t data ) ;
        // #ifndef _DRV_PMP_STATIC_H
 /*******************************************************************************
  End of File
 */

 #endif /*00 C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\system_config\default\framework\driver\pmp\drv_pmp_static.h*/
 /*   CLOSE_FILE Include File */

 /* OPEN FILE C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\system_config\default\framework\driver\usart\drv_usart_static.h */
 /*******************************************************************************
  USART Driver Interface Declarations for Static Single Instance Driver
  Company:
  Microchip Technology Inc.
  File Name:
  drv_usart_static.h
  Summary:
  USART driver interface declarations for the static single instance driver.
  Description:
  The USART device driver provides a simple interface to manage the USART
  modules on Microchip microcontrollers. This file defines the interface
  Declarations for the USART static driver.
  Remarks:
  Static interfaces incorporate the driver instance number within the names
  of the routines, eliminating the need for an object ID or object handle.
  Static single-open interfaces also eliminate the need for the open handle.
 *******************************************************************************/
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2015 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
 *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _DRV_USART_STATIC_H
 #define _DRV_USART_STATIC_H
 // *****************************************************************************
 // *****************************************************************************
 // Section: Included Files
 // *****************************************************************************
 // *****************************************************************************
 /* OPEN FILE C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\system_config\default\framework\driver\usart\src\drv_usart_static_local.h */
 /*******************************************************************************
  USART Driver Local Data Structures for static implementation
  Company:
  Microchip Technology Inc.
  File Name:
  drv_usart_static_local.h
  Summary:
  USART Driver Local Data Structures for static implementation
  Description:
  Driver Local Data Structures for static implementation
 *******************************************************************************/
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2015 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute Software
 only when embedded on a Microchip microcontroller or digital signal controller
 that is integrated into your product or third party product (pursuant to the
 sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
 *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _DRV_USART_STATIC_LOCAL_H
 #define _DRV_USART_STATIC_LOCAL_H
 // *****************************************************************************
 // *****************************************************************************
 // Section: Included Files
 // *****************************************************************************
 // *****************************************************************************
 #include <stdint.h>
 #include <stdbool.h>
 #include <stddef.h>
 /* OPEN FILE C:\microchip\harmony\v2_06\framework\driver\usart\drv_usart.h */
 /*******************************************************************************
  USART Driver Interface Header File
  Company:
  Microchip Technology Inc.
  File Name:
  drv_usart.h
  Summary:
  USART Driver Interface Header File
  Description:
  The USART device driver provides a simple interface to manage the USART or
  UART modules on Microchip microcontrollers. This file provides the
  interface definition for the USART driver.
 *******************************************************************************/
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2012-2014 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
 *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _DRV_USART_H
 #define _DRV_USART_H
 // *****************************************************************************
 // *****************************************************************************
 // Section: File includes
 // *****************************************************************************
 // *****************************************************************************
 /* OPEN FILE C:\microchip\harmony\v2_06\framework\driver\usart\drv_usart_definitions.h */
 /*******************************************************************************
  USART Driver Definitions Header File
  Company:
  Microchip Technology Inc.
  File Name:
  drv_usart_definitions.h
  Summary:
  USART Driver Definitions Header File
  Description:
  This file will provide enumerations and other dependencies needed by
  USART driver to manage the USART/UART module on PIC32 microcontrollers.
 *******************************************************************************/
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2012-2014 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
 *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _DRV_USART_DEFINITIONS_H
 #define _DRV_USART_DEFINITIONS_H
 // *****************************************************************************
 // *****************************************************************************
 // Section: File includes
 // *****************************************************************************
 // *****************************************************************************
 #include "C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\system_config\default\system_config.h"  /* LDRA full path */
 #include "C:\microchip\harmony\v2_06\framework\driver\driver_common.h"  /* LDRA full path */
 /* OPEN FILE C:\microchip\harmony\v2_06\framework\peripheral\usart\plib_usart.h */
 /*******************************************************************************
  USART Peripheral Library Interface Header
  Company:
  Microchip Technology Inc.
  File Name:
  plib_usart.h
  Summary:
  USART Peripheral Library interface header.
  Description:
  This header file contains the function prototypes and definitions of
  the data types and constants that make up the interface to the USART
  Peripheral Library for all families of Microchip microcontrollers. The
  functions in this file are common to the USART module.
  *******************************************************************************/
 // DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright 2010-2015 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
  *******************************************************************************/
 // DOM-IGNORE-END
 #ifndef _PLIB_USART_H
 #define _PLIB_USART_H
 // DOM-IGNORE-BEGIN
 // DOM-IGNORE-END
 // ****************************************************************************
 // ****************************************************************************
 // Section: Included Files
 // ****************************************************************************
 // ****************************************************************************
 /* This section lists the other files that are included in this file.
 */
 /* OPEN FILE C:\microchip\harmony\v2_06\framework\peripheral\usart\processor\usart_processor.h */
 /*******************************************************************************
   Processor Selector File for the USART
   Company:
     Microchip Technology Incorporated
   File Name:
     processor.h
   Summary:
     Selects the appropriate header for the part family
   Description:
     This file selects the appropriate header for the part family
  *******************************************************************************/
 // DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2012 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
  *******************************************************************************/
 // DOM-IGNORE-END
 #ifndef _USART_PROCESSOR_H
 #define _USART_PROCESSOR_H
 // *****************************************************************************
 // *****************************************************************************
 // Section: Included Files
 // *****************************************************************************
 // *****************************************************************************
 /* This section lists the other files that are included in this file.
  */
 #include <stdint.h>
 #include <stdbool.h>
 #error "No Processor Family specified"
        //
        // _USART_PROCESSOR_H
 /*******************************************************************************
  End of File
  */
 #endif /*00 C:\microchip\harmony\v2_06\framework\peripheral\usart\processor\usart_processor.h*/
 /*   CLOSE_FILE Include File */

 // ****************************************************************************
 // ****************************************************************************
 // Section: USART Peripheral Library Interface Functions
 // ****************************************************************************
 // ****************************************************************************
 //******************************************************************************
 /* Function:
     void PLIB_USART_RunInOverflowEnable ( USART_MODULE_ID index )
   Summary:
     Enables the USART module to continue to operate when an overflow error
     condition has occurred.
   Description:
     This function enables the USART module to continue to operate when an
     overflow error condition has occurred.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_RunInOverflowEnable (MY_USART_INSTANCE);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsRunInOverflow in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_RunInOverflowEnable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_RunInOverflowDisable ( USART_MODULE_ID index )
   Summary:
     Disables the Run in overflow condition mode.
   Description:
     This function disables the USART module from accepting new data when an overflow
     error condition is detected.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_RunInOverflowDisable (MY_USART_INSTANCE);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsRunInOverflow in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_RunInOverflowDisable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_USART_RunInOverflowIsEnabled ( USART_MODULE_ID index )
   Summary:
     Gets the status of the Run in Overflow condition.
   Description:
     This function indicates if the USART module has been enabled to run in
     an overflow condition.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - Run in overflow condition is enabled
     - false - Run in overflow condition is disabled
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     bool status;
     status = PLIB_USART_RunInOverflowIsEnabled (MY_USART_INSTANCE);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsRunInOverflow in your application to determine
     whether this feature is available.
 */

 bool
   PLIB_USART_RunInOverflowIsEnabled (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_BRGClockSourceSelect
     (
         USART_MODULE_ID index,
         USART_BRG_CLOCK_SOURCE brgClockSource
     )
   Summary:
     Configures the BRG clock source of the USART module.
   Description:
     This function configures the BRG Clock source of the USART. Refer to
         USART_BRG_CLOCK_SOURCE for the possible clock sources.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     brgClockSource - One of the possible values from USART_BRG_CLOCK_SOURCE
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_BRGClockSourceSelect (MY_USART_INSTANCE, USART_BRG_CLOCK_SOURCE_FRC_IN_SLEEP);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsBRGClockSourceSelect in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_BRGClockSourceSelect (
   USART_MODULE_ID index ,
   USART_BRG_CLOCK_SOURCE brgClockSource ) ;
 //******************************************************************************
 /* Function:
     USART_BRG_CLOCK_SOURCE PLIB_USART_BRGClockSourceGet ( USART_MODULE_ID index )
   Summary:
     Gets the BRG clock source of the USART module.
   Description:
     This function returns the BRG Clock source of the USART. Refer to
     USART_BRG_CLOCK_SOURCE for the possible clock sources.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     One of the possible values of USART_BRG_CLOCK_SOURCE
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     USART_BRG_CLOCK_SOURCE brgClockSource;
     brgClockSource = PLIB_USART_BRGClockSourceGet (MY_USART_INSTANCE);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsBRGClockSourceSelect in your application to determine
     whether this feature is available.
 */

 USART_BRG_CLOCK_SOURCE
   PLIB_USART_BRGClockSourceGet (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_USART_ModuleIsBusy ( USART_MODULE_ID index )
   Summary:
     Returns the USART module's running status.
   Description:
     This function checks if the USART module status is busy. The following
     functions should not be used when the module status is busy:
     - PLIB_USART_LineControlModeSelect
     - PLIB_USART_BaudRateHighSet
     - PLIB_USART_BaudRateHighEnable
     - PLIB_USART_BaudRateHighDisable
     - PLIB_USART_ReceiverIdleStateLowEnable
     - PLIB_USART_ReceiverIdleStateLowDisable
     - PLIB_USART_BaudRateAutoDetectEnable
     - PLIB_USART_LoopbackEnable
     - PLIB_USART_LoopbackDisable
     - PLIB_USART_WakeOnStartEnable
     - PLIB_USART_WakeOnStartDisable
     - PLIB_USART_OperationModeSelect
     - PLIB_USART_HandshakeModeSelect
     - PLIB_USART_IrDAEnable
     - PLIB_USART_IrDADisable
     - PLIB_USART_StopInIdleEnable
     - PLIB_USART_StopInIdleDisable
     - PLIB_USART_RunInOverflowEnable
     - PLIB_USART_RunInOverflowDisable
     - PLIB_USART_BRGClockSourceSelect
     - PLIB_USART_RunInSleepModeEnable
     - PLIB_USART_RunInSleepModeDisable
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - USART module is busy
     - false - USART module is idle
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     bool moduleStatus;
     moduleStatus = PLIB_USART_ModuleIsBusy (MY_USART_INSTANCE);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsModuleBusyStatus in your application to determine
     whether this feature is available.
 */

 bool
   PLIB_USART_ModuleIsBusy (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_RunInSleepModeEnable ( USART_MODULE_ID index )
   Summary:
     Allows the USART module's BRG clock to run when the device enters Sleep mode.
   Description:
     This function enables the USART module's BRG clock to continue operation when
     the device enters the Sleep mode.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_RunInSleepModeEnable (MY_USART_INSTANCE);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsRunInSleepMode in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_RunInSleepModeEnable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_RunInSleepModeDisable ( USART_MODULE_ID index )
   Summary:
     Turns off the USART module's BRG clock during Sleep mode.
   Description:
     This function turns off the USART module's BRG clock during Sleep mode.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_RunInSleepModeDisable (MY_USART_INSTANCE);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsRunInSleepMode in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_RunInSleepModeDisable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_USART_RunInSleepModeIsEnabled ( USART_MODULE_ID index )
   Summary:
     Gets the status of Run in Sleep mode.
   Description:
     This function indicates if the USART module has been enabled to run in
     Sleep mode.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - Run in Sleep mode is enabled
     - false - Run in Sleep mode is disabled
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     bool status;
     status = PLIB_USART_RunInSleepModeIsEnabled (MY_USART_INSTANCE);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsRunInSleepMode in your application to determine
     whether this feature is available.
 */

 bool
   PLIB_USART_RunInSleepModeIsEnabled (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_Enable ( USART_MODULE_ID index )
   Summary:
     Enables the specific USART module.
   Description:
     This function enables the specific USART module.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_Enable(MY_USART_INSTANCE);
     </code>
   Remarks:
     By calling this function, the USART pins are controlled by the USART
     module.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsEnable in your application to determine whether
     this feature is available.
 */

 void
   PLIB_USART_Enable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_Disable ( USART_MODULE_ID index )
   Summary:
     Disables the specific USART module
   Description:
     This function disables the specific USART module.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_Disable(MY_USART_INSTANCE);
     </code>
   Remarks:
     The default state after any reset for a USART module is the disable state.
     If the USART is disabled, all of the related pins are in control of the
     general purpose I/O logic.

     Disabling the USART module resets the buffers to empty states. Any data
     characters in the buffers are lost and the baud rate is reset. All error
     and status bits are also reset.

     Disabling the USART while the USART is active, will abort all pending
     transmissions and receptions. Re-enabling the USART will restart the
     module in the same configuration.

     When disabled, the USART power consumption is minimal.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsEnable in your application to determine whether
     this feature is available.
 */

 void
   PLIB_USART_Disable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_TransmitterEnable ( USART_MODULE_ID index )
   Summary:
     Enables the specific USART module transmitter.
   Description:
     This function enables the specific USART module transmitter.
     This operation is atomic.
   Precondition:
     The USART module should be enabled using the function PLIB_USART_Enable
     before this function is called.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_TransmitterEnable(MY_USART_INSTANCE);
     </code>
   Remarks:
     The transmitter should not be enabled until the USART is enabled.
     The transmissions will not be enabled otherwise.

     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsTransmitterEnable in your application to determine whether
     this feature is available.
 */

 void
   PLIB_USART_TransmitterEnable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_TransmitterDisable ( USART_MODULE_ID index )
   Summary:
     Disables the specific USART module transmitter.
   Description:
     This function disables the specific USART module transmitter.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_TransmitterDisable(MY_USART_INSTANCE);
     </code>
   Remarks:
     Disabling the transmitter during a transmission will cause the
     transmission to be aborted.

     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsTransmitterEnable in your application to determine whether
     this feature is available.
 */

 void
   PLIB_USART_TransmitterDisable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_BaudRateSet ( USART_MODULE_ID index, uint32_t clockFrequency,
             uint32_t baudRate );
   Summary:
     Sets the baud rate to the desired value.
   Description:
     This function sets the baud rate to the desired value.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     baudRate - Baud Rate Value
     clockFrequency - Clock Frequency
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     uint32_t baudRateValue ;
     PLIB_USART_BaudRateSet(MY_USART_INSTANCE, MY_CLOCK_FREQUENCY, 9600);
     baudRateValue = PLIB_USART_BaudRateGet(MY_USART_INSTANCE, MY_CLOCK_FREQUENCY);
     </code>
   Remarks:
     Setting a new baud rate value causes the baud rate timer to reset.
     This ensures that the baud rate timer does not have to overflow before
     outputting the new baud rate.

     If the system clock is changed during an active receive operation, a
     receiver error or data loss may result. To avoid this issue verify that
     no receptions are in progress before changing the system clock.

     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsBaudRate in your application to determine whether
     this feature is available.
 */

 void
   PLIB_USART_BaudRateSet (
   USART_MODULE_ID index ,
   uint32_t clockFrequency ,
   uint32_t baudRate ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_BaudRateHighSet ( USART_MODULE_ID index,
             uint32_t clockFrequency, uint32_t baudRate );
   Summary:
     Sets the baud rate to the desired value.
   Description:
     This function sets the baud rate to the desired value.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     baudRate - Baud Rate Value, it is the baud rate value
     clockFrequency - Clock Frequency
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     uint32_t baudRateValue ;
     PLIB_USART_BaudRateHighSet(MY_USART_INSTANCE, MY_CLOCK_FREQUENCY, 9600);
     baudRateValue = PLIB_USART_BaudRateGet(MY_USART_INSTANCE, MY_CLOCK_FREQUENCY);
     </code>
   Remarks:
     Setting a new baud rate value causes the baud rate timer to reset.
     This ensures that the baud rate timer does not have to overflow before
     outputting the new baud rate.

     If the system clock is changed during an active receive operation, a
     receiver error or data loss may result. To avoid this issue verify that
     no receptions are in progress before changing the system clock.

     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsBaudRateHigh in your application to determine whether
     this feature is available.
 */

 void
   PLIB_USART_BaudRateHighSet (
   USART_MODULE_ID index ,
   uint32_t clockFrequency ,
   uint32_t baudRate ) ;
 //******************************************************************************
 /* Function:
       uint32_t PLIB_USART_BaudRateGet ( USART_MODULE_ID index,
                     int32_t clockFrequency );
   Summary:
     Gets the baud rate current in use.
   Description:
     This function gets the baud rate that is currently in use. The clock frequency
     needs to be passed to the function.
   Conditions:
     None.
   Input:
     index - Identifier for the device instance to be configured
     clockFrequency - Clock Frequency
   Returns:
     - BaudRate - Baud rate value
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     uint32_t baudRate ;
     PLIB_USART_BaudRateSet(MY_USART_INSTANCE, MY_CLOCK_FREQUENCY, 9600);
     baudRate = PLIB_USART_BaudRateGet(MY_USART_INSTANCE, MY_CLOCK_FREQUENCY);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsBaudRate in your application to determine whether
     this feature is available.
 */

 uint32_t
   PLIB_USART_BaudRateGet (
   USART_MODULE_ID index ,
   int32_t clockFrequency ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_AddressSet
     (
         USART_MODULE_ID index,
         uint8_t address
     )
   Summary:
     Sets the address for the Address Detect mode.
   Description:
     This function sets the address for the Address Detect mode.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     address - Address
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     uint8_t address = 0x02;
     PLIB_USART_AddressSet (MY_USART_INSTANCE, address);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsReceiverAddress in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_AddressSet (
   USART_MODULE_ID index ,
   uint8_t address ) ;
 //******************************************************************************
 /* Function:
     uint8_t PLIB_USART_AddressGet
     (
         USART_MODULE_ID index
     )
   Summary:
     Gets the address for the Address Detect mode.
   Description:
     This function returns the address value being used for the Address
     Detect mode.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - address - The address being used
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     uint8_t address = 0;
     address = PLIB_USART_AddressGet (MY_USART_INSTANCE);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsReceiverAddress in your application to determine
     whether this feature is available.
 */

 uint8_t
   PLIB_USART_AddressGet (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_AddressMaskSet
     (
         USART_MODULE_ID index,
         uint8_t mask
     )
   Summary:
     Sets the address mask for the Address Detect mode.
   Description:
     This function sets the address mask for the Address Detect mode.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     mask - Address match mask bits
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     uint8_t mask = 0x0F;
     PLIB_USART_AddressMaskSet (MY_USART_INSTANCE, mask);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsReceiverAddressMask in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_AddressMaskSet (
   USART_MODULE_ID index ,
   uint8_t mask ) ;
 //******************************************************************************
 /* Function:
     uint8_t PLIB_USART_AddressMaskGet
     (
         USART_MODULE_ID index
     )
   Summary:
     Gets the address mask for the Address Detect mode.
   Description:
     This function returns the address mask value being used for the Address
     Detect mode.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     - mask - Address mask being used
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     uint8_t mask = 0;
     mask = PLIB_USART_AddressMaskGet (MY_USART_INSTANCE);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsReceiverAddressMask in your application to determine
     whether this feature is available.
 */

 uint8_t
   PLIB_USART_AddressMaskGet (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_ReceiverAddressDetectEnable ( USART_MODULE_ID index )
   Summary:
     Enables the Address Detect mode.
   Description:
     This function enables the Address Detect mode. If it is enabled, and the
     device is addressed, disable the Address Detect mode to continue receiving
     bytes.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_ReceiverAddressDetectEnable(MY_USART_INSTANCE);
     </code>
   Remarks:
     If 9 data bits are not selected, this bit has no effect.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsReceiverAddressDetect in your application to determine whether
     this feature is available.
 */

 void
   PLIB_USART_ReceiverAddressDetectEnable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_ReceiverAddressDetectDisable ( USART_MODULE_ID index )
   Summary:
     Enables the Address Detect mode.
   Description:
     This function disables the Address Detect mode. If it is enabled, and the
     device is addressed, disable the Address Detect mode to continue receiving
     bytes.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_ReceiverAddressDetectDisable(MY_USART_INSTANCE);
     </code>
   Remarks:
     All bytes are received, and the 9th bit can be used as the parity bit.
     By default, the address detect is disabled.

     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsReceiverAddressDetect in your application to determine whether
     this feature is available.
 */

 void
   PLIB_USART_ReceiverAddressDetectDisable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_USART_BaudRateAutoDetectIsComplete ( USART_MODULE_ID index )
   Summary:
     Gets the state of the automatic baud detection.
   Description:
     This function gets the state of the automatic baud detection and returns a '0'
     if the baud rate auto detection is complete.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     - true - Baud rate detection is not complete
     - false - Baud rate detection is complete
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_BaudRateAutoDetectEnable(MY_USART_INSTANCE);
     // Wait until the baud rate is detected.
     while(!PLIB_USART_BaudRateAutoDetectIsComplete(MY_USART_INSTANCE));
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsBaudRateAutoDetect in your application to determine whether
     this feature is available.
 */

 bool
   PLIB_USART_BaudRateAutoDetectIsComplete (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_BaudRateAutoDetectEnable ( USART_MODULE_ID index )
   Summary:
     Enables baud rate measurement on the next character, which requires reception
     of the Sync character.
   Description:
     This function enables the baud rate measurement on the next character,
     which requires reception of the Sync character.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_BaudRateAutoDetectEnable(MY_USART_INSTANCE);
     // Wait until the baud rate is detected.
     while(!PLIB_USART_BaudRateAutoDetectIsComplete(MY_USART_INSTANCE));
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsBaudRateAutoDetect in your application to determine whether
     this feature is available.
 */

 void
   PLIB_USART_BaudRateAutoDetectEnable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_TransmitterByteSend ( USART_MODULE_ID index, int8_t data )
   Summary:
     Data to be transmitted in the Byte mode.
   Description:
     The data is transmitted in the Byte mode for the specified USART module.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     data - Data to be transmitted.
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     uint8_t data = 'a';
     if(!PLIB_USART_TransmitterBufferIsFull(MY_USART_INSTANCE))
     {
         PLIB_USART_TransmitterByteSend(MY_USART_INSTANCE, data);
     }
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsTransmitter in your application to determine whether
     this feature is available.
 */

 void
   PLIB_USART_TransmitterByteSend (
   USART_MODULE_ID index ,
   int8_t data ) ;
 //******************************************************************************
 /* Function:
     int8_t PLIB_USART_ReceiverByteReceive ( USART_MODULE_ID index )
   Summary:
     Data to be received in the Byte mode.
   Description:
     The data to be received in Byte mode from the specified USART module.
     This operation is atomic.
     Call the functions PLIB_USART_ReceiverFramingErrorHasOccurred,
     PLIB_USART_ReceiverParityErrorHasOccurred and
     PLIB_USART_ReceiverOverrunHasOccurred to get any error that occurred.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     - data - Data to be received
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     bool isError;
     uint8_t mydata;
         if(PLIB_USART_ReceiverDataIsAvailable(MY_USART_INSTANCE))
     {
         mydata = PLIB_USART_ReceiverByteReceive(MY_USART_INSTANCE);
     }
     isError = PLIB_USART_ReceiverFramingErrorHasOccurred(MY_USART_INSTANCE) |
                    PLIB_USART_ReceiverParityErrorHasOccurred(MY_USART_INSTANCE) |
                    PLIB_USART_ReceiverOverrunHasOccurred(MY_USART_INSTANCE);
     if(PLIB_USART_ReceiverOverrunHasOccurred(MY_USART_INSTANCE))
     {
         PLIB_USART_ReceiverOverrunErrorClear(MY_USART_INSTANCE);
     }
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsReceiver in your application to determine whether
     this feature is available.
 */

 int8_t
   PLIB_USART_ReceiverByteReceive (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     int16_t PLIB_USART_Receiver9BitsReceive ( USART_MODULE_ID index )
   Summary:
     Data to be received in the byte mode with the 9th bit.
   Description:
     The data to be received in Byte mode from the specified USART module.
     with the 9th bit.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     - data - Data to be received
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     uint16_t mydata;
         if(PLIB_USART_ReceiverDataIsAvailable(MY_USART_INSTANCE))
     {
         mydata = PLIB_USART_Receiver9BitsReceive (MY_USART_INSTANCE);
     }
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsReceiver9Bits in your application to determine
     whether this feature is available.
 */

 int16_t
   PLIB_USART_Receiver9BitsReceive (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_USART_ReceiverAddressIsReceived ( USART_MODULE_ID index )
   Summary:
     Checks and return if the data received is an address.
   Description:
     Checks and return if the data received is an address. The address has
     the 9th bit set. If data received has the 9th bit set, the function returns true;
         otherwise, the function returns false.
     This operation is atomic.
   Precondition:
     The USART module should be configured to use the 9 data bits.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     - true - if the data received has the 9th bit set
     - false - if the address received has the 9th bit cleared
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     int8_t address;
     if(PLIB_USART_ReceiverAddressIsReceived(MY_USART_INSTANCE))
     {
         address = PLIB_USART_ReceiverByteReceive(MY_USART_INSTANCE);
     }
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsReceiverAddressDetect in your application to determine whether
     this feature is available.
 */

 bool
   PLIB_USART_ReceiverAddressIsReceived (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_Transmitter9BitsSend ( USART_MODULE_ID index,
             int8_t data, bool 9thBit )
   Summary:
     Data to be transmitted in the byte mode with the 9th bit.
   Description:
     The data is transmitted in the byte mode for the specified USART module,
     with 9th bit.
     This operation is atomic.
   Precondition:
     The USART module should be configured to use the 9 data bits.
   Parameters:
     index - Identifier for the device instance to be configured
     data - Data to be transmitted.
     9thBit - 9th bit of the data to be transmitted.
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     uint8_t data = 'a';
     if(!PLIB_USART_TransmitterBufferIsFull(MY_USART_INSTANCE))
     {
         PLIB_USART_Transmitter9BitsSend(MY_USART_INSTANCE, data, false);
     }
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsTransmitter9BitsSend in your application to determine whether
     this feature is available.
 */

 void
   PLIB_USART_Transmitter9BitsSend (
   USART_MODULE_ID index ,
   int8_t data ,
   bool Bit9th ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_TransmitterBreakSend ( USART_MODULE_ID index )
   Summary:
     Transmits the break character.
   Description:
     This function transmits the break character.
     This operation is atomic.
   Precondition:
     The application should wait for the transmitter to be idle, before calling
     this function.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     // Wait for the Transmit buffer to be empty.
     while(PLIB_USART_TransmitterBufferIsFull(MY_USART_INSTANCE));
     // Transmit the break character.
     PLIB_USART_TransmitterBreakSend(MY_USART_INSTANCE);
     // wait for the break transmission to complete
     while(!PLIB_USART_TransmitterBreakSendIsComplete(MY_USART_INSTANCE));
     </code>
   Remarks:
     After the break has been transmitted, the application can start
     transmitting next bytes.

     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsTransmitterBreak in your application to determine whether
     this feature is available.
 */

 void
   PLIB_USART_TransmitterBreakSend (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_USART_TransmitterBreakSendIsComplete ( USART_MODULE_ID index )
   Summary:
     Returns the status of the break transmission
   Description:
     The function returns the status of the break transmission.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     - true - Transmit break on the next transmission
     - false - Break transmission completed or not started
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     // Wait for the Transmit buffer to be empty.
     while(PLIB_USART_TransmitterBufferIsFull(MY_USART_INSTANCE));
     // Transmit the break character.
     PLIB_USART_TransmitterBreakSend(MY_USART_INSTANCE);
     // wait for the break transmission to complete
     while(!PLIB_USART_TransmitterBreakSendIsComplete(MY_USART_INSTANCE));
     </code>
   Remarks:
     After the break has been transmitted, the application can start
     transmitting next bytes.

     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsTransmitterBreak in your application to determine whether
     this feature is available.
 */

 bool
   PLIB_USART_TransmitterBreakSendIsComplete (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_USART_ReceiverDataIsAvailable ( USART_MODULE_ID index )
   Summary:
     Identifies if the receive data is available for the specified USART module.
   Description:
     This function identifies if the receive data is available for the specified
     USART module.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     - true - The data is available
     - false - The data is not available
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     int8_t mydata;
     if(PLIB_USART_ReceiverDataIsAvailable(MY_USART_INSTANCE))
     {
         mydata = PLIB_USART_ReceiverByteReceive(MY_USART_INSTANCE);
     }
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsReceiverDataAvailableStatus in your application to determine
     whether this feature is available.
 */

 bool
   PLIB_USART_ReceiverDataIsAvailable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_ReceiverOverrunErrorClear ( USART_MODULE_ID index )
   Summary:
    Clears a USART vverrun error.
   Description:
     This function clears an overrun error. Clearing the error, resets the receive buffer.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     if(PLIB_USART_ReceiverOverrunHasOccurred(MY_USART_INSTANCE))
     {
         PLIB_USART_ReceiverOverrunErrorClear(MY_USART_INSTANCE);
     }
     </code>
   Remarks:
         WARNING: Calling this API will clear all of the previously received data.

     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsReceiverOverrunStatus in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_ReceiverOverrunErrorClear (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_USART_TransmitterBufferIsFull ( USART_MODULE_ID index )
   Summary:
     Gets the transmit buffer full status.
   Description:
     This function gets the transmit status of the specified USART module.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     - true - The transmit buffer is full
     - false - The transmit buffer is not full, at least one more
                         character can be written
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     // Wait for the Transmit buffer to be empty.
     while(PLIB_USART_TransmitterBufferIsFull(MY_USART_INSTANCE));
     // Transmit the break character.
     PLIB_USART_TransmitterBreakSend(MY_USART_INSTANCE);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsTransmitterBufferFullStatus in your application to determine
     whether this feature is available.
 */

 bool
   PLIB_USART_TransmitterBufferIsFull (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
      bool PLIB_USART_TransmitterIsEmpty ( USART_MODULE_ID index )
   Summary:
     Gets the transmit shift register empty status.
   Description:
     This function gets the transmit shift register empty status.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     - true - The transmit shift register is empty
     - false - The transmit shift register is not empty
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     // Wait for the Transmit buffer to be empty.
     while(!PLIB_USART_TransmitterIsEmpty(MY_USART_INSTANCE));
     // Transmit the break character.
     PLIB_USART_TransmitterBreakSend(MY_USART_INSTANCE);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsTransmitterEmptyStatus in your application to determine
     whether this feature is available.
 */

 bool
   PLIB_USART_TransmitterIsEmpty (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
      bool PLIB_USART_ReceiverFramingErrorHasOccurred ( USART_MODULE_ID index )
   Summary:
     Gets the framing error status.
   Description:
     This function gets the framing error status.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     - true - The framing error was detected on the current character
     - false - The framing error was not detected on the current
                         character
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     status = PLIB_USART_ReceiverFramingErrorHasOccurred(MY_USART_INSTANCE);
     </code>
   Remarks:
     Reading the error clears the error.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsReceiverFramingErrorStatus in your application to determine
     whether this feature is available.
 */

 bool
   PLIB_USART_ReceiverFramingErrorHasOccurred (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_USART_ReceiverParityErrorHasOccurred ( USART_MODULE_ID index )
   Summary:
     Gets the parity error status.
   Description:
     This function gets the parity error status.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     - true - The parity error was detected on the current character
     - false - The parity error was not detected on the current character
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     status = PLIB_USART_ReceiverParityErrorHasOccurred(MY_USART_INSTANCE);
     </code>
   Remarks:
     Reading the error clears the error.
     A Parity error is irrelevant in case of 9-bit mode.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsReceiverParityErrorStatus in your application to determine
     whether this feature is available.
 */

 bool
   PLIB_USART_ReceiverParityErrorHasOccurred (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_USART_ReceiverOverrunHasOccurred ( USART_MODULE_ID index )
   Summary:
     Identifies if there was a receiver overrun error.
   Description:
     This function identifies if there was a receiver overrun error.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     - true - The receive buffer has overflowed
     - false - The receive buffer has not overflowed
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     if(PLIB_USART_ReceiverOverrunHasOccurred(MY_USART_INSTANCE))
     {
         PLIB_USART_ReceiverOverrunErrorClear(MY_USART_INSTANCE);
     }
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsReceiverOverrunStatus in your application to determine
     whether this feature is available.
 */

 bool
   PLIB_USART_ReceiverOverrunHasOccurred (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_USART_ReceiverIsIdle ( USART_MODULE_ID index )
   Summary:
     Identifies if the receiver is idle.
   Description:
     This function identifies if the receiver is idle.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     - true - The receive buffer is idle
     - false - The receive buffer is not idle
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     int8_t mydata;
     if(PLIB_USART_ReceiverIsIdle(MY_USART_INSTANCE))
     {
         mydata = PLIB_USART_ReceiverByteReceive(MY_USART_INSTANCE);
     }
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsReceiverIdleStatus in your application to determine
     whether this feature is available.
 */

 bool
   PLIB_USART_ReceiverIsIdle (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_ReceiverEnable ( USART_MODULE_ID index )
   Summary:
     Enables the USART receiver.
   Description:
     This function enables the USART receiver.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_ReceiverEnable(MY_USART_INSTANCE);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsReceiverEnable in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_ReceiverEnable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_ReceiverDisable ( USART_MODULE_ID index )
   Summary:
     Disables the USART receiver.
   Description:
     This function disables the USART receiver.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_ReceiverDisable(MY_USART_INSTANCE);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsReceiverEnable in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_ReceiverDisable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_TransmitterIdleIsLowEnable ( USART_MODULE_ID index )
   Summary:
     Enables the Transmit Idle Low state.
   Description:
     This function enables the Transmit Idle Low state. In the USART Synchronous
     mode, this function configures that the TX polarity, the idle state is low.
     When IrDA is enabled, this function sets that IrDA encoded Transmit Idle
     state to a '1'.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_TransmitterIdleIsLowEnable(MY_USART_INSTANCE);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsTransmitterIdleIsLow in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_TransmitterIdleIsLowEnable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_TransmitterIdleIsLowDisable ( USART_MODULE_ID index )
   Summary:
     Disables the Transmit Idle Low state.
   Description:
     This function disables the Transmit Idle Low state. In USART Synchronous mode,
     this function configures that the TX polarity the idle state is high.
     When IrDA is enabled, this function sets the IrDA encoded Transmit Idle
     state to a '0'.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_TransmitterIdleIsLowDisable(MY_USART_INSTANCE);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsTransmitterIdleIsLow in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_TransmitterIdleIsLowDisable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_ReceiverIdleStateLowEnable ( USART_MODULE_ID index )
   Summary:
     Enables receive polarity inversion.
   Description:
     This function enables receive polarity inversion. In the USART Synchronous mode,
     this function configures that the data is inverted.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_ReceiverIdleStateLowEnable(MY_USART_INSTANCE);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsReceiverIdleStateLowEnable in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_ReceiverIdleStateLowEnable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_ReceiverIdleStateLowDisable ( USART_MODULE_ID index );
   Summary:
     Disables receive polarity inversion.
     This operation is atomic.
   Description:
     This function disables receive polarity inversion. In the USART Synchronous
     mode, this function configures that the data is not inverted.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_ReceiverIdleStateLowDisable(MY_USART_INSTANCE);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsReceiverIdleStateLowEnable in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_ReceiverIdleStateLowDisable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_BaudRateHighEnable ( USART_MODULE_ID index )
   Summary:
     Enables high baud rate selection.
   Description:
     This function enables high baud rate selection.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_BaudRateHighEnable(MY_USART_INSTANCE);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsBaudRateHigh in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_BaudRateHighEnable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_BaudRateHighDisable ( USART_MODULE_ID index )
   Summary:
     Disables the high baud rate selection.
   Description:
     This function disables the high baud rate selection.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_BaudRateHighDisable(MY_USART_INSTANCE);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsBaudRateHigh in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_BaudRateHighDisable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_TransmitterInterruptModeSelect( USART_MODULE_ID index,
             USART_TRANSMIT_INTR_MODE interruptMode )
   Summary:
     Sets the USART transmitter interrupt mode.
   Description:
     This function sets the condition in which the USART module should generate
     an interrupt.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     interruptMode - Interrupt mode; for possible configurations, refer to
                       USART_TRANSMIT_INTR_MODE
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_TransmitterInterruptModeSelect(MY_USART_INSTANCE,
         USART_TRANSMIT_FIFO_EMPTY );
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsTransmitterInterruptMode in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_TransmitterInterruptModeSelect (
   USART_MODULE_ID index ,
   USART_TRANSMIT_INTR_MODE fifolevel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_ReceiverInterruptModeSelect( USART_MODULE_ID index,
             USART_RECEIVE_INTR_MODE interruptMode )
   Summary:
     Sets the USART receiver FIFO level.
   Description:
     This function sets the USART receiver FIFO level.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     fifolevel - For possible configurations, refer to USART_RECEIVE_INTR_MODE
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_ReceiverInterruptModeSelect(MY_USART_INSTANCE,
         USART_RECEIVE_FIFO_ONE_CHAR );
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsReceiverInterruptMode in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_ReceiverInterruptModeSelect (
   USART_MODULE_ID index ,
   USART_RECEIVE_INTR_MODE interruptMode ) ;
 //******************************************************************************
 /* Function:
      void PLIB_USART_LineControlModeSelect(USART_MODULE_ID index,
                 USART_LINECONTROL_MODE dataFlowConfig)
   Summary:
     Sets the data flow configuration.
   Description:
     This function sets the USART data flow configuration based on the mask
     provided and the specified baud rate.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     mode - For possible data flow configurations, refer to
                       USART_LINECONTROL_MODE
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_LineControlModeSelect(MY_USART_INSTANCE, \
                                         USART_8N1);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsLineControlMode in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_LineControlModeSelect (
   USART_MODULE_ID index ,
   USART_LINECONTROL_MODE dataFlowConfig ) ;
 //******************************************************************************
 /* Function:
      void PLIB_USART_HandshakeModeSelect(USART_MODULE_ID index,
                 USART_HANDSHAKE_MODE handshakeConfig)
   Summary:
     Sets the data flow configuration.
   Description:
     This function sets the USART data flow configuration based on the mask
     provided and the specified baud rate.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     mode - For possible data flow configurations, refer to
                       USART_HANDSHAKE_MODE
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_HandshakeModeSelect(MY_USART_INSTANCE, \
                                         USART_HANDSHAKE_MODE_SIMPLEX);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsHandshakeMode in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_HandshakeModeSelect (
   USART_MODULE_ID index ,
   USART_HANDSHAKE_MODE handshakeConfig ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_ReceiverAddressAutoDetectEnable(USART_MODULE_ID index,
             int8_t Mask)
   Summary:
     Setup the automatic Address Detect mode.
   Description:
     This function configures the automatic Address Detect mode. Uses the mask as
     the address character for automatic address detection.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     Mask - Address character to be used, when enabled
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_ReceiverAddressAutoDetectEnable(MY_USART_INSTANCE,
                   MY_DEVICE_ADDRESS);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsReceiverAddressAutoDetect in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_ReceiverAddressAutoDetectEnable (
   USART_MODULE_ID index ,
   int8_t Mask ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_ReceiverAddressAutoDetectDisable (
             USART_MODULE_ID index )
   Summary:
     Disables the automatic Address Detect mode.
   Description:
     This function disables the automatic Address Detect mode.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_ReceiverAddressAutoDetectDisable(MY_USART_INSTANCE);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsReceiverAddressAutoDetect in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_ReceiverAddressAutoDetectDisable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_IrDAEnable ( USART_MODULE_ID index )
   Summary:
     Enables the IrDA encoder and decoder.
   Description:
     This function enables the IrDA encoder and decoder.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_IrDAEnable(MY_USART_INSTANCE);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsIrDA in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_IrDAEnable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_IrDADisable ( USART_MODULE_ID index )
   Summary:
     Disables the IrDA encoder and decoder.
   Description:
     This function disables the IrDA encoder and decoder.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_IrDADisable(MY_USART_INSTANCE);
     </code>
   Remarks:
     By default, the IrDA Encoder and Decoder are disabled.

     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsIrDA in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_IrDADisable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_LoopbackEnable ( USART_MODULE_ID index )
   Summary:
     Enables Loopback mode.
   Description:
     This function enables Loopback mode.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_LoopbackEnable(MY_USART_INSTANCE);
     </code>
   Remarks:
     By default, Loopback mode is disabled.

     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsLoopback in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_LoopbackEnable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_LoopbackDisable ( USART_MODULE_ID index )
   Summary:
     Disables Loopback mode.
   Description:
     This function disables Loopback mode.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_LoopbackDisable(MY_USART_INSTANCE);
     </code>
   Remarks:
     By default, Loopback mode is disabled.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsLoopback in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_LoopbackDisable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_OperationModeSelect(USART_MODULE_ID index,
             USART_OPERATION_MODE operationmode)
   Summary:
     Configures the operation mode of the USART module.
   Description:
     This function configures the operation mode of the USART (i.e., controls the
     pins used by the USART module). Refer to USART_OPERATION_MODE for the
     possible settings.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     operationmode - One of the possible values from USART_OPERATION_MODE
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_OperationModeSelect(MY_USART_INSTANCE, USART_ENABLE_TX_RX_BCLK_USED);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsOperationMode in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_OperationModeSelect (
   USART_MODULE_ID index ,
   USART_OPERATION_MODE operationmode ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_StopInIdleEnable ( USART_MODULE_ID index )
   Summary:
     Discontinues operation when the device enters Idle mode.
   Description:
     This function enables the USART module to discontinue operation when the
     device enters Idle mode.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_StopInIdleEnable(MY_USART_INSTANCE);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsStopInIdle in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_StopInIdleEnable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_StopInIdleDisable ( USART_MODULE_ID index )
   Summary:
     Disables the Stop in Idle mode (the USART module continues operation when
     the device is in Idle mode).
   Description:
     This function disables the Stop in Idle mode. The USART module continues
     operation when the device is in Idle mode.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_StopInIdleDisable(MY_USART_INSTANCE);
     </code>
   Remarks:
     By default, the USART module will continue operation in Idle mode.

     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsStopInIdle in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_StopInIdleDisable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_WakeOnStartEnable ( USART_MODULE_ID index )
   Summary:
     Enables the wake-up on start bit detection feature during Sleep mode.
   Description:
     This function enables the wake-up on start feature during Sleep mode.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_WakeOnStartEnable(MY_USART_INSTANCE);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsWakeOnStart in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_WakeOnStartEnable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_WakeOnStartDisable ( USART_MODULE_ID index )
   Summary:
     Disables the wake-up on start bit detection feature during Sleep mode.
   Description:
     This function disables the wake-up on start bit detection feature during
     Sleep mode.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     PLIB_USART_WakeOnStartDisable(MY_USART_INSTANCE);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsWakeOnStart in your application to determine
     whether this feature is available.
 */

 void
   PLIB_USART_WakeOnStartDisable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_USART_WakeOnStartIsEnabled ( USART_MODULE_ID index )
   Summary:
     Gets the state of the sync break event completion.
   Description:
     This function returns the status of the sync break event, when called
     after enabling using PLIB_USART_WakeOnStartEnable.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     //Call the interface just prior to entering the sleep mode.
     PLIB_USART_WakeOnStartEnable(MY_USART_INSTANCE);
     // Check the status if the Sync break event is over.
     if(PLIB_USART_WakeOnStartIsEnabled(MY_USART_INSTANCE))
     {
        // Do Something
     }
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     PLIB_USART_ExistsWakeOnStart in your application to determine
     whether this feature is available.
 */

 bool
   PLIB_USART_WakeOnStartIsEnabled (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_InitializeModeGeneral( USART_MODULE_ID index, bool autobaud,
         bool loopBackMode, bool wakeFromSleep, bool irdaMode, bool stopInIdle );
   Summary:
     Enables or disables general features of the USART module.
   Description:
     This function enables or disables general features of the USART module.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     autobaud - If true, auto baud rate detection is enabled. If false
                       the feature is disabled.
     loopBackMode - If true, loop back is enabled. If false the feature is
                       disabled.
     wakeFromSleep - If true, the USART module will wake up the CPU from sleep
                       mode on USART activity. If false the feature is disabled.
     irdaMode - If true, the IrDA mode is enabled. If false the feature
                       is disabled.
     stopInIdle - If true, module will stop functioning when CPU enters Idle
                       mode. If false, the feature is disabled.
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     // Enable loopback, disable IrDA, disable auto baud detection and disable
     // wake from sleep. Enable stop in idle
     PLIB_USART_InitializeModeGeneral(MY_USART_INSTANCE, false, true,
                                                         false, false, true);
     </code>
   Remarks:
     Enabling the wake from sleep feature will cause the first character that is
     received by the USART module to be discarded. This feature should only be
     enabled if the CPU is to placed in power saving mode.

     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability. Availability of this
     function can also be determined if all of the following functions return
     true:
     - PLIB_USART_ExistsLoopback
     - PLIB_USART_ExistsBaudRateAutoDetect
     - PLIB_USART_ExistsWakeOnStart
     - PLIB_USART_ExistsIrDA
     - PLIB_USART_ExistsStopInIdle
 */

 void
   PLIB_USART_InitializeModeGeneral (
   USART_MODULE_ID index ,
   bool autobaud ,
   bool loopBackMode ,
   bool wakeFromSleep ,
   bool irdaMode ,
   bool stopInIdle ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_InitializeOperation( USART_MODULE_ID index ,
             USART_RECEIVE_INTR_MODE receiveInterruptMode,
             USART_TRANSMIT_INTR_MODE transmitInterruptMode,
             USART_OPERATION_MODE operationMode);
   Summary:
     Configures the Receive and Transmit FIFO interrupt levels and the hardware
     lines to be used by the module.
   Description:
     This function configures the Receive and Transmit FIFO interrupt levels and
     the hardware lines to be used by the module.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     receiveInterruptMode - Receiver FIFO interrupt level
     transmitInterruptMode - Transmit FIFO interrupt level
     operationMode - Hardware lines to be used by the USART.
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     // Set receive FIFO to interrupt when FIFO is 3/4 level full
     // Set Transmit FIFO to interrupt when FIFO is empty
     // USART module will only use RX and TX hardware lines
     PLIB_USART_InitializeOperation(MY_USART_INSTANCE, USART_RECEIVE_FIFO_3B4FULL,
         USART_TRANSMIT_FIFO_EMPTY , USART_ENABLE_TX_RX_USED);
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability. Availability of this
     function can also be determined if all of the following functions return
     true:
     - PLIB_USART_ExistsReceiverInterruptMode
     - PLIB_USART_ExistsTransmitterInterruptMode
     - PLIB_USART_ExistsOperationMode
 */

 void
   PLIB_USART_InitializeOperation (
   USART_MODULE_ID index ,
   USART_RECEIVE_INTR_MODE receiveInterruptMode ,
   USART_TRANSMIT_INTR_MODE transmitInterruptMode ,
   USART_OPERATION_MODE operationMode ) ;
 //******************************************************************************
 /* Function:
     void PLIB_USART_BaudSetAndEnable ( USART_MODULE_ID index, uint32_t
                                         clockFrequency, uint32_t baudRate );
   Summary:
     Sets the baud rate to the desired value and enables the USART receiver,
     transmitter and the USART module.
   Description:
     This function sets the baud rate to the desired value and enables the USART
     receiver, USART transmitter and USART module.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     baudRate - Baud Rate Value
     clockFrequency - Clock Frequency
   Returns:
     None.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     uint32_t baudRateValue ;
     PLIB_USART_BaudSetAndEnable(MY_USART_INSTANCE, MY_CLOCK_FREQUENCY, 9600);
     </code>
   Remarks:
     Setting a new baud rate value causes the baud rate timer to reset.
     This ensures that the baud rate timer does not have to overflow before
     outputting the new baud rate.

     If the system clock is changed during an active receive operation, a
     receiver error or data loss may result. To avoid this issue verify that
     no receptions are in progress before changing the system clock.

     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability. Availability of this
     function can also be determined if all of the following functions return
     true:
     - PLIB_USART_ExistsBaudRate
     - PLIB_USART_ExistsTransmitterEnable
     - PLIB_USART_ExistsReceiverEnable
     - PLIB_USART_ExistsEnable
 */

 void
   PLIB_USART_BaudSetAndEnable (
   USART_MODULE_ID index ,
   uint32_t systemClock ,
   uint32_t baud ) ;
 //******************************************************************************
 /* Function:
     USART_ERROR PLIB_USART_ErrorsGet ( USART_MODULE_ID index )
   Summary:
     Return the status of all errors in the specified USART module.
   Description:
     This function returns status of all errors in the specified USART module.
     The return value can be bitwise AND'ed with a USART_ERROR type to know the
     status of a specific error.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     Returns a bitmap of USART error status.
   Example:
     <code>
 #define MY_USART_INSTANCE USART_ID_1
     USART_ERROR error;
     // Get the status of all errors.
     error = PLIB_USART_ErrorsGet(MY_USART_INSTANCE);
     // Check if parity error is active
     if(error & USART_ERROR_PARITY)
     {
         // Parity error is active.
     }
     else if(error & USART_ERROR_FRAMING)
     {
         // Framing error is active.
     }
     </code>
   Remarks:
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability. Availability of this
     function can also be determined if all of the followings functions return
     true:
     - PLIB_USART_ExistsReceiverFramingErrorStatus
     - PLIB_USART_ExistsReceiverParityErrorStatus
     - PLIB_USART_ExistsReceiverOverrunStatus
 */

 USART_ERROR
   PLIB_USART_ErrorsGet (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_TransmitterAddressGet( USART_MODULE_ID index )
   Summary:
     Returns the address of the USART TX register
   Description:
     This function returns the address of the USART TX register.
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     Address of the USART TX register
   Remarks:
     None.
 */

 void *
   PLIB_USART_TransmitterAddressGet (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ReceiverAddressGet( USART_MODULE_ID index )
   Summary:
     Returns the address of the USART RX register
   Description:
     This function returns the address of the USART RX register.
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     Address of the USART RX register
   Remarks:
     None.
 */

 void *
   PLIB_USART_ReceiverAddressGet (
   USART_MODULE_ID index ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: USART Peripheral Library Exists Functions
 // *****************************************************************************
 // *****************************************************************************
 /* The following functions indicate the existence of the features on the device.
 */
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsRunInOverflow ( USART_MODULE_ID index )
   Summary:
     Identifies whether the Run in overflow condition feature exists on the USART module.
   Description:
     This function identifies whether the Run in Overflow condition feature is
     available on the USART module. When this function returns true, these
     functions are supported on the device:
     - PLIB_USART_RunInOverflowEnable
     - PLIB_USART_RunInOverflowDisable
     - PLIB_USART_RunInOverflowIsEnabled
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The Run in Overflow condition feature is supported on the device
     - false - The Run in Overflow condition feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsRunInOverflow (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsBRGClockSourceSelect ( USART_MODULE_ID index )
   Summary:
     Identifies whether the BRG Clock source select feature exists on the
         USART module.
   Description:
     This function identifies whether the BRG Clock source select feature is
     available on the USART module. When this function returns true, these
     functions are supported on the device:
     - PLIB_USART_BRGClockSourceSelect
     - PLIB_USART_BRGClockSourceGet
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The BRG clock source select feature is supported on the device
     - false - The BRG clock source select feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsBRGClockSourceSelect (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsModuleBusyStatus ( USART_MODULE_ID index )
   Summary:
     Identifies whether the module running status feature exists on the
         USART module.
   Description:
     This function identifies whether the module running status feature is
     available on the USART module. When this function returns true, this
     function is supported on the device:
     - PLIB_USART_ModuleIsBusy
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The Module running status feature is supported on the device
     - false - The Module running status feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsModuleBusyStatus (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsRunInSleepMode ( USART_MODULE_ID index )
   Summary:
     Identifies whether the Run in Sleep mode feature exists on the USART module.
   Description:
     This function identifies whether the Run in Sleep mode feature is
     available on the USART module. When this function returns true, these
     functions are supported on the device:
     - PLIB_USART_RunInSleepModeEnable
     - PLIB_USART_RunInSleepModeDisable
     - PLIB_USART_RunInSleepModeIsEnabled
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The Run in Sleep mode feature is supported on the device
     - false - The Run in Sleep mode feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsRunInSleepMode (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsEnable( USART_MODULE_ID index )
   Summary:
     Identifies whether the EnableControl feature exists on the USART module.
   Description:
     This function identifies whether the EnableControl feature is
     available on the USART module. When this function returns true, these
     functions are supported on the device:
     - PLIB_USART_Disable
     - PLIB_USART_Enable
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The EnableControl feature is supported on the device
     - false - The EnableControl feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsEnable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsHandshakeMode( USART_MODULE_ID index )
   Summary:
     Identifies whether the HandShakeMode feature exists on the USART module.
   Description:
     This function identifies whether the HandShakeMode feature is
     available on the USART module. When this function returns true, this
     function is supported on the device:
     - PLIB_USART_HandshakeModeSelect
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The HandShakeMode feature is supported on the device
     - false - The HandShakeMode feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsHandshakeMode (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsIrDA( USART_MODULE_ID index )
   Summary:
     Identifies whether the IrDAControl feature exists on the USART module.
   Description:
     This function identifies whether the IrDAControl feature is
     available on the USART module. When this function returns true, these
     functions are supported on the device:
     - PLIB_USART_IrDADisable
     - PLIB_USART_IrDAEnable
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The IrDAControl feature is supported on the device
     - false - The IrDAControl feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsIrDA (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsLineControlMode( USART_MODULE_ID index )
   Summary:
     Identifies whether the LineControlMode feature exists on the USART module.
   Description:
     This function identifies whether the LineControlMode feature is
     available on the USART module. When this function returns true, this
     function is supported on the device:
     - PLIB_USART_LineControlModeSelect
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The LineControlMode feature is supported on the device
     - false - The LineControlMode feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsLineControlMode (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsLoopback( USART_MODULE_ID index )
   Summary:
     Identifies whether the Loopback feature exists on the USART module.
   Description:
     This function identifies whether the Loopback feature is
     available on the USART module. When this function returns true, these
     functions are supported on the device:
     - PLIB_USART_LoopbackEnable
     - PLIB_USART_LoopbackDisable
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The Loopback feature is supported on the device
     - false - The Loopback feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsLoopback (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsOperationMode( USART_MODULE_ID index )
   Summary:
     Identifies whether the OperationMode feature exists on the USART module.
   Description:
     This function identifies whether the OperationMode feature is
     available on the USART module. When this function returns true, this
     function is supported on the device:
     - PLIB_USART_OperationModeSelect
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The OperationMode feature is supported on the device
     - false - The OperationMode feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsOperationMode (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsStopInIdle( USART_MODULE_ID index )
   Summary:
     Identifies whether the StopInIdle feature exists on the USART module.
   Description:
     This function identifies whether the StopInIdle feature is
     available on the USART module. When this function returns true, these
     functions are supported on the device:
     - PLIB_USART_StopInIdleEnable
     - PLIB_USART_StopInIdleDisable
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The StopInIdle feature is supported on the device
     - false - The StopInIdle feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsStopInIdle (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsWakeOnStart( USART_MODULE_ID index )
   Summary:
     Identifies whether the WakeOnStart feature exists on the USART module.
   Description:
     This function identifies whether the WakeOnStart feature is
     available on the USART module. When this function returns true, these
     functions are supported on the device:
     - PLIB_USART_WakeOnStartEnable
     - PLIB_USART_WakeOnStartDisable
     - PLIB_USART_WakeOnStartIsEnabled
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The WakeOnStart feature is supported on the device
     - false - The WakeOnStart feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsWakeOnStart (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsBaudRate( USART_MODULE_ID index )
   Summary:
     Identifies whether the BaudRate feature exists on the USART module.
   Description:
     This function identifies whether the BaudRate feature is
     available on the USART module. When this function returns true, these
     functions are supported on the device:
     - PLIB_USART_BaudRateSet
     - PLIB_USART_BaudRateGet
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The BaudRate feature is supported on the device
     - false - The BaudRate feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsBaudRate (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsBaudRateAutoDetect( USART_MODULE_ID index )
   Summary:
     Identifies whether the BaudRateAutoDetect feature exists on the USART module.
   Description:
     This function identifies whether the BaudRateAutoDetect feature is
     available on the USART module. When this function returns true, these
     functions are supported on the device:
     - PLIB_USART_BaudRateAutoDetectEnable
     - PLIB_USART_BaudRateAutoDetectIsComplete
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The BaudRateAutoDetect feature is supported on the device
     - false - The BaudRateAutoDetect feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsBaudRateAutoDetect (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsBaudRateHigh( USART_MODULE_ID index )
   Summary:
     Identifies whether the BaudRateHigh feature exists on the USART module.
   Description:
     This function identifies whether the BaudRateHigh feature is
     available on the USART module. When this function returns true, these
     functions are supported on the device:
     - PLIB_USART_BaudRateHighSet
     - PLIB_USART_BaudRateHighDisable
     - PLIB_USART_BaudRateHighEnable
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The BaudRateHigh feature is supported on the device
     - false - The BaudRateHigh feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsBaudRateHigh (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsReceiverAddress ( USART_MODULE_ID index )
   Summary:
     Identifies whether the Receiver Address feature exists on the USART
     module.
   Description:
     This function identifies whether the Receiver Address feature is
     available on the USART module. When this function returns true, these
     functions are supported on the device:
     - PLIB_USART_AddressSet
     - PLIB_USART_AddressGet
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The Receiver address feature is supported on the device
     - false - The Receiver address feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsReceiverAddress (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsReceiverAddressMask ( USART_MODULE_ID index )
   Summary:
     Identifies whether the Receiver Address Mask feature exists on the USART
     module.
   Description:
     This function identifies whether the Receiver Address Mask feature is
     available on the USART module. When this function returns true, these
     functions are supported on the device:
     - PLIB_USART_AddressMaskSet
     - PLIB_USART_AddressMaskGet
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The Receiver address mask feature is supported on the device
     - false - The Receiver address mask feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsReceiverAddressMask (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsReceiver( USART_MODULE_ID index )
   Summary:
     Identifies whether the Receiver feature exists on the USART module.
   Description:
     This function identifies whether the Receiver feature is available on the
     USART module. When this function returns true, these functions are supported
     on the device:
     - PLIB_USART_ReceiverByteReceive
     - PLIB_USART_ReceiverAddressGet
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The Receiver feature is supported on the device
     - false - The Receiver feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsReceiver (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsReceiver9Bits ( USART_MODULE_ID index )
   Summary:
     Identifies whether the 9 Bits Receiver feature exists on the USART module.
   Description:
     This function identifies whether the 9 Bits Receiver feature is available on the
     USART module. When this function returns true, this function is supported
     on the device:
     - PLIB_USART_Receiver9BitsReceive
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The feature is supported on the device
     - false - The feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsReceiver9Bits (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsReceiverAddressAutoDetect( USART_MODULE_ID index )
   Summary:
     Identifies whether the ReceiverAddressAutoDetect feature exists on the USART module.
   Description:
     This function identifies whether the ReceiverAddressAutoDetect feature is
     available on the USART module. When this function returns true, these
     functions are supported on the device:
     - PLIB_USART_ReceiverAddressAutoDetectEnable
     - PLIB_USART_ReceiverAddressAutoDetectDisable
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ReceiverAddressAutoDetect feature is supported on the device
     - false - The ReceiverAddressAutoDetect feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsReceiverAddressAutoDetect (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsReceiverAddressDetect( USART_MODULE_ID index )
   Summary:
     Identifies whether the ReceiverAddressDetect feature exists on the USART module.
   Description:
     This function identifies whether the ReceiverAddressDetect feature is
     available on the USART module. When this function returns true, these
     functions are supported on the device:
     - PLIB_USART_ReceiverAddressDetectEnable
     - PLIB_USART_ReceiverAddressDetectDisable
     - PLIB_USART_ReceiverAddressIsReceived
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ReceiverAddressDetect feature is supported on the device
     - false - The ReceiverAddressDetect feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsReceiverAddressDetect (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsReceiverDataAvailableStatus( USART_MODULE_ID index )
   Summary:
     Identifies whether the ReceiverDataAvailable feature exists on the USART
     module
   Description:
     This function identifies whether the ReceiverDataAvailable feature is
     available on the USART module. When this function returns true, this
     function is supported on the device:
     - PLIB_USART_ReceiverDataIsAvailable
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ReceiverDataAvailable feature is supported on the device
     - false - The ReceiverDataAvailable feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsReceiverDataAvailableStatus (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsReceiverEnable( USART_MODULE_ID index )
   Summary:
     Identifies whether the ReceiverEnableControl feature exists on the USART module.
   Description:
     This function identifies whether the ReceiverEnableControl feature is
     available on the USART module. When this function returns true, these
     functions are supported on the device:
     - PLIB_USART_ReceiverEnable
     - PLIB_USART_ReceiverDisable
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ReceiverEnableControl feature is supported on the device
     - false - The ReceiverEnableControl feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsReceiverEnable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsReceiverIdleStatus( USART_MODULE_ID index )
   Summary:
     Identifies whether the ReceiverIdle feature exists on the USART module.
   Description:
     This function identifies whether the ReceiverIdle feature is
     available on the USART module. When this function returns true, this
     function is supported on the device:
     - PLIB_USART_ReceiverIsIdle
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ReceiverIdle feature is supported on the device
     - false - The ReceiverIdle feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsReceiverIdleStatus (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsReceiverFramingErrorStatus( USART_MODULE_ID index )
   Summary:
     Identifies whether the ReceiverFramingError feature exists on the USART module.
   Description:
     This function identifies whether the ReceiverFramingError feature is
     available on the USART module. When this function returns true, this
     function is supported on the device:
     - PLIB_USART_ReceiverFramingErrorHasOccurred
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ReceiverFramingError feature is supported on the device
     - false - The ReceiverFramingError feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsReceiverFramingErrorStatus (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsReceiverInterruptMode( USART_MODULE_ID index )
   Summary:
     Identifies whether the ReceiverInterruptMode feature exists on the USART module.
   Description:
     This function identifies whether the ReceiverInterruptMode feature is
     available on the USART module. When this function returns true, this
     function is supported on the device:
     - PLIB_USART_ReceiverInterruptModeSelect
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ReceiverInterruptMode feature is supported on the device
     - false - The ReceiverInterruptMode feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsReceiverInterruptMode (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsReceiverIdleStateLowEnable( USART_MODULE_ID index )
   Summary:
     Identifies whether the ReceiverPolarityInvert feature exists on the USART module.
   Description:
     This function identifies whether the ReceiverPolarityInvert feature is
     available on the USART module. When this function returns true, these
     functions are supported on the device:
     - PLIB_USART_ReceiverIdleStateLowEnable
     - PLIB_USART_ReceiverIdleStateLowDisable
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ReceiverPolarityInvert feature is supported on the device
     - false - The ReceiverPolarityInvert feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsReceiverIdleStateLowEnable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsReceiverParityErrorStatus( USART_MODULE_ID index )
   Summary:
     Identifies whether the ReceiverParityError feature exists on the USART module.
   Description:
     This function identifies whether the ReceiverParityError feature is
     available on the USART module. When this function returns true, this
     function is supported on the device:
     - PLIB_USART_ReceiverParityErrorHasOccurred
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ReceiverParityError feature is supported on the device
     - false - The ReceiverParityError feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsReceiverParityErrorStatus (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsReceiverOverrunStatus( USART_MODULE_ID index )
   Summary:
     Identifies whether the ReceiverOverrunError feature exists on the USART module.
   Description:
     This function identifies whether the ReceiverOverrunError feature is
     available on the USART module. When this function returns true, these
     functions are supported on the device:
     - PLIB_USART_ReceiverOverrunErrorClear
     - PLIB_USART_ReceiverOverrunHasOccurred
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ReceiverOverrunError feature is supported on the device
     - false - The ReceiverOverrunError feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsReceiverOverrunStatus (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsTransmitter( USART_MODULE_ID index )
   Summary:
     Identifies whether the Transmitter feature exists on the USART module.
   Description:
     This function identifies whether the Transmitter feature is
     available on the USART module. When this function returns true, these
     functions are supported on the device:
     - PLIB_USART_TransmitterByteSend
     - PLIB_USART_TransmitterAddressGet
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The Transmitter feature is supported on the device
     - false - The Transmitter feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsTransmitter (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsTransmitter9BitsSend( USART_MODULE_ID index )
   Summary:
     Identifies whether the Transmitter9Bits feature exists on the USART module.
   Description:
     This function identifies whether the Transmitter9Bits feature is
     available on the USART module. When this function returns true, this
     function is supported on the device:
     - PLIB_USART_Transmitter9BitsSend
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The Transmitter9Bits feature is supported on the device
     - false - The Transmitter9Bits feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsTransmitter9BitsSend (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsTransmitterBreak( USART_MODULE_ID index )
   Summary:
     Identifies whether the TransmitterBreak feature exists on the USART module.
   Description:
     This function identifies whether the TransmitterBreak feature is
     available on the USART module. When this function returns true, these
     functions are supported on the device:
     - PLIB_USART_TransmitterBreakSend
     - PLIB_USART_TransmitterBreakSendIsComplete
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The TransmitterBreak feature is supported on the device
     - false - The TransmitterBreak feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsTransmitterBreak (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsTransmitterBufferFullStatus( USART_MODULE_ID index )
   Summary:
     Identifies whether the TransmitterBufferFull feature exists on the USART module.
   Description:
     This function identifies whether the TransmitterBufferFull feature is
     available on the USART module. When this function returns true, this
     function is supported on the device:
     - PLIB_USART_TransmitterBufferIsFull
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The TransmitterBufferFull feature is supported on the device
     - false - The TransmitterBufferFull feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsTransmitterBufferFullStatus (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsTransmitterEmptyStatus( USART_MODULE_ID index )
   Summary:
     Identifies whether the TransmitterEmpty feature exists on the USART module.
   Description:
     This function identifies whether the TransmitterEmpty feature is
     available on the USART module. When this function returns true, this
     function is supported on the device:
     - PLIB_USART_TransmitterIsEmpty
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The TransmitterEmpty feature is supported on the device
     - false - The TransmitterEmpty feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsTransmitterEmptyStatus (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsTransmitterEnable( USART_MODULE_ID index )
   Summary:
     Identifies whether the TransmitterEnableControl feature exists on the USART
     module
   Description:
     This function identifies whether the TransmitterEnableControl feature is
     available on the USART module. When this function returns true, these
     functions are supported on the device:
     - PLIB_USART_TransmitterEnable
     - PLIB_USART_TransmitterDisable
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The TransmitterEnableControl feature is supported on the device
     - false - The TransmitterEnableControl feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsTransmitterEnable (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsTransmitterInterruptMode( USART_MODULE_ID index )
   Summary:
     Identifies whether the TransmitterInterruptMode feature exists on the USART module.
   Description:
     This function identifies whether the TransmitterInterruptMode feature is
     available on the USART module. When this function returns true, this function
     is supported on the device:
     - PLIB_USART_TransmitterInterruptModeSelect
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The TransmitterInterruptMode feature is supported on the device
     - false - The TransmitterInterruptMode feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsTransmitterInterruptMode (
   USART_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_USART_ExistsTransmitterIdleIsLow( USART_MODULE_ID index )
   Summary:
     Identifies whether the TransmitterIdleIsLow feature exists on the USART module.
   Description:
     This function identifies whether the TransmitterIdleIsLow feature is available
     on the USART module. When this function returns true, these functions are
     supported on the device:
     - PLIB_USART_TransmitterIdleIsLowDisable
     - PLIB_USART_TransmitterIdleIsLowEnable
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The TransmitterIdleIsLow feature is supported on the device
     - false - The TransmitterIdleIsLow feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_USART_ExistsTransmitterIdleIsLow (
   USART_MODULE_ID index ) ;
 //DOM-IGNORE-BEGIN
 //DOM-IGNORE-END
        // #ifndef _PLIB_USART_H
 /******************************************************************************
  End of File
 */

 #endif /*00 C:\microchip\harmony\v2_06\framework\peripheral\usart\plib_usart.h*/
 /*   CLOSE_FILE Include File */

 /* OPEN FILE C:\microchip\harmony\v2_06\framework\system\system.h */
 /*******************************************************************************
  System Services Library Interface Header
  Company:
  Microchip Technology Inc.
  File Name:
  system.h
  Summary:
  Top level common system services library interface header.
  Description:
  This file is the top level common system services library interface header.
  It defines (or includes files that define) the common system service
  types, prototypes, and other definitions that are commonly used by MPLAB
  Harmony libraries and system services.

  System services provide common functionality that would otherwise need to
  be duplicated by multiple other modules or that would force them to
  interact in complex and hard to manage ways. System services eliminate
  conflicts by controlling access shared resources.
  Remarks:
  The parent directory to the "system" directory should be added to the
  compiler's search path for header files such that the following include
  statment will successfully include this file.

 #include "system/system.h"
  *******************************************************************************/
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2011-2015 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED 'AS IS' WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
  *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _SYSTEM_H
 #define _SYSTEM_H
 // *****************************************************************************
 // *****************************************************************************
 // Section: Included Files
 // *****************************************************************************
 // *****************************************************************************
 #include "system/common/sys_common.h"
 #include "system/common/sys_module.h"
 // DOM-IGNORE-BEGIN
 // DOM-IGNORE-END
 //DOM-IGNORE-BEGIN
 //DOM-IGNORE-END
        // _SYSTEM_H
 /*******************************************************************************
  End of File
 */
 #endif /*00 C:\microchip\harmony\v2_06\framework\system\system.h*/
 /*   CLOSE_FILE Include File */

 #include "system/int/sys_int.h"
 /* OPEN FILE C:\microchip\harmony\v2_06\framework\system\dma\sys_dma.h */
 /*******************************************************************************
  DMA System Service Library Interface Definition
  Company:
  Microchip Technology Inc.
  File Name:
  sys_dma.h
  Summary:
  DMA System Service.
  Description:
  This file contains the interface definition for the DMA System
  Service. It provides a way to interact with the DMA subsystem to
  manage the data transfer between different peripherals and/or memory
  without intervention from the CPU.
 *******************************************************************************/
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2013-2015 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
 *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _SYS_DMA_H
 #define _SYS_DMA_H
 /* OPEN FILE C:\microchip\harmony\v2_06\framework\system\dma\sys_dma_definitions.h */
 /*******************************************************************************
  DMA System Service Library Interface Definition
  Company:
  Microchip Technology Inc.
  File Name:
  sys_dma_definitions.h
  Summary:
  DMA System Service data type definitions header.
  Description:
  This file contains data type definitions header.
 *******************************************************************************/
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2013-2015 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
 *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _SYS_DMA_DEFINITIONS_H
 #define _SYS_DMA_DEFINITIONS_H
 // *****************************************************************************
 // *****************************************************************************
 // Section: File includes
 // *****************************************************************************
 // *****************************************************************************
 #include "C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\system_config\default\system_config.h"  /* LDRA full path */
 #include "system/common/sys_common.h"
 #include "system/common/sys_module.h"
 /* OPEN FILE C:\microchip\harmony\v2_06\framework\peripheral\dma\plib_dma.h */
 /*******************************************************************************
  DMA Peripheral Library Interface Header
  Company:
  Microchip Technology Inc.
  File Name:
  plib_dma.h
  Summary:
  Defines the DMA Peripheral Library interface functions.
  Description:
  This header file contains the function prototypes and definitions of
  the data types and constants that make up the interface to the Direct Memory
  Access (DMA) Peripheral Library for Microchip microcontrollers. The
  definitions in this file are for the DMA module.
 *******************************************************************************/
 // DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright 2013-2015 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
 *******************************************************************************/
 // DOM-IGNORE-END
 #ifndef _PLIB_DMA_H
 #define _PLIB_DMA_H
 // DOM-IGNORE-BEGIN
 // DOM-IGNORE-END
 // *****************************************************************************
 // *****************************************************************************
 // Section: Includes
 // *****************************************************************************
 // *****************************************************************************
 /* See Bottom of file for implementation header include files.
 */
 /* OPEN FILE C:\microchip\harmony\v2_06\framework\peripheral\dma\processor\dma_processor.h */
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2011-2016 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED 'AS IS' WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
  *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _PLIB_DMA_PROCESSOR_H
 #define _PLIB_DMA_PROCESSOR_H
 #error "Can't find header"
 #endif /*00 C:\microchip\harmony\v2_06\framework\peripheral\dma\processor\dma_processor.h*/
 /*   CLOSE_FILE Include File */

 // *****************************************************************************
 // *****************************************************************************
 // Section: Peripheral Library Interface Functions
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 // Section: DMA Channel Status Functions
 // *****************************************************************************
 // *****************************************************************************
 //******************************************************************************
 /* Function:
     bool PLIB_DMA_ChannelXBufferedDataIsWritten ( DMA_MODULE_ID index,
                                                     DMA_CHANNEL channel )
   Summary:
     Returns the buffered data write status for the specified channel.
   Description:
     This function returns the buffered data write status for the specified channel.
   Precondition:
     None.
   Parameters:
     channel     - One of the existing DMA channels listed by DMA_CHANNEL
   Returns:
     - true - The content of the DMA buffer has not been written to the location
                 specified in the destination/source address or in Null Write mode
     - false - The content of the DMA buffer has been written to the location
                 specified in the destination/source address or in Null Write mode
   Example:
     <code>
         bool chBuffWriteStatus;
     chBuffWriteStatus = PLIB_DMA_ChannelXBufferedDataIsWritten( DMA_ID_0,
                                                                 DMA_CHANNEL_3 );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific device
     data sheet to determine availability.
 */

 bool
   PLIB_DMA_ChannelXBufferedDataIsWritten (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 /*******************************************************************************
   Function:
     bool PLIB_DMA_ChannelXCollisionStatus ( DMA_MODULE_ID index,
                                             DMA_CHANNEL channel,
                                             DMA_CHANNEL_COLLISION collisonType )
   Summary:
     Returns the status of the specified collision type for the specified channel.
   Description:
     This function returns the status of the specified collision type for the
         specified channel.
   Precondition:
     None.
   Parameters:
     channel - One of the existing DMA channels listed by DMA_CHANNEL
     collisonType - Collision type listed by DMA_CHANNEL_COLLISION
   Returns:
     - true - A collision specified by collisonType was detected
     - false - No collision of type collisonType was detected
   Example:
     <code>
         bool memWriteCollisionStatus;
         memWriteCollisionStatus = PLIB_DMA_ChannelXMemoryWriteCollisionStatus(
                                                 DMA_ID_0,
                                                 DMA_CHANNEL_3,
                                                 DMA_CHANNEL_COLLISION_MEMORY );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 bool
   PLIB_DMA_ChannelXCollisionStatus (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ,
   DMA_CHANNEL_COLLISION collisonType ) ;
 //******************************************************************************
 /* Function:
     DMA_PING_PONG_MODE PLIB_DMA_ChannelXPingPongModeGet( DMA_MODULE_ID index,
                                                             DMA_CHANNEL channel )
   Summary:
     Returns the Ping-Pong mode status for the specified channel.
   Description:
     This function returns the Ping-Pong mode status for the specified channel.
   Precondition:
     None.
   Parameters:
     channel     - One of the existing DMA channels listed by DMA_CHANNEL
   Returns:
     mode - One of the possible Ping-Pong modes
   Example:
     <code>
         DMA_PING_PONG_MODE chPingPongStatus;
     chPingPongStatus = PLIB_DMA_ChannelXPingPongModeGet(DMA_ID_0,
                                                         DMA_CHANNEL_3 );
     if (DMA_PING_PONG_SECONDARY == chPingPongStatus)
         {
             \\Application
         }
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 DMA_PING_PONG_MODE
   PLIB_DMA_ChannelXPingPongModeGet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_DMA_ChannelXEventIsDetected ( DMA_MODULE_ID index,
                                             DMA_CHANNEL channel )
   Summary:
     Returns the event status on the specified channel.
   Description:
     This function returns the event status on the specified channel.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     - true      - An event was detected
     - false     - No events were detected
   Example:
     <code>
         bool channeleventStatus;
     channeleventStatus = PLIB_DMA_ChannelXEventIsDetected( DMA_ID_0,
                                                             DMA_CHANNEL_2 );
     </code>
   Remarks:
         This function implements an operation of the ChannelXEvent feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or include the
         PLIB_DMA_ExistsChannelXEvent function in your application to determine
         whether this feature is available.
 */

 bool
   PLIB_DMA_ChannelXEventIsDetected (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: DMA Channel Configuration Functions
 // *****************************************************************************
 // *****************************************************************************
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXPrioritySelect ( DMA_MODULE_ID index,
                                             DMA_CHANNEL channel,
                                             DMA_CHANNEL_PRIORITY channelPriority )
   Summary:
     Sets the priority of the specified channel.
   Description:
     This function sets the priority of the specified channel.
   Precondition:
     None.
   Parameters:
     channel      - One of the existing DMA channels listed by DMA_CHANNEL
     channelPriority     - One of the supported priorities listed by DMA_CHANNEL_PRIORITY
   Returns:
     None.
   Example:
     <code>
         DMA_CHANNEL channel = DMA_CHANNEL_0;
         DMA_CHANNEL_PRIORITY channelPriority = DMA_CHANNEL_PRIORITY_3;
     PLIB_DMA_ChannelXPrioritySelect( DMA_ID_0, channel, channelPriority );
     </code>
   Remarks:
         This function implements an operation of the ChannelXPriority feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXPriority function in your application to determine
         whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXPrioritySelect (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ,
   DMA_CHANNEL_PRIORITY channelPriority ) ;
 //******************************************************************************
 /* Function:
     DMA_CHANNEL_PRIORITY PLIB_DMA_ChannelXPriorityGet ( DMA_MODULE_ID index,
                                                         DMA_CHANNEL channel )
   Summary:
     Gets the priority of the specified channel.
   Description:
     This function gets the priority of the specified channel.
   Precondition:
     None.
   Parameters:
     channel      - One of the existing DMA channels listed by DMA_CHANNEL
   Returns:
         - channelPriority - One of the supported priorities listed by DMA_CHANNEL_PRIORITY
   Example:
     <code>
         DMA_CHANNEL channel = DMA_CHANNEL_0;
         DMA_CHANNEL_PRIORITY channelPriority;
     channelPriority = PLIB_DMA_ChannelXPriorityGet( DMA_ID_0, channel );
     </code>
   Remarks:
         This function implements an operation of the ChannelXPriority feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXPriority function in your application to determine
         whether this feature is available.
 */

 DMA_CHANNEL_PRIORITY
   PLIB_DMA_ChannelXPriorityGet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelPrioritySelect ( DMA_MODULE_ID index,
                                             DMA_CHANNEL_PRIORITY channelPriority )
   Summary:
     Sets the priority scheme of the DMA channels.
   Description:
     This function sets the priority scheme of the DMA channels at the global level.
     This function is used in devices that do not have the per channel priority feature.
   Precondition:
     None.
   Parameters:
         channelPriority - One of the supported priorities listed by DMA_CHANNEL_PRIORITY
   Returns:
     None.
   Example:
     <code>
         DMA_CHANNEL_PRIORITY channelPriority = DMA_CHANNEL_ROUND_ROBIN;
     PLIB_DMA_ChannelPrioritySelect( DMA_ID_0, channelPriority );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 void
   PLIB_DMA_ChannelPrioritySelect (
   DMA_MODULE_ID index ,
   DMA_CHANNEL_PRIORITY channelPriority ) ;
 //******************************************************************************
 /* Function:
     DMA_CHANNEL_PRIORITY PLIB_DMA_ChannelPriorityGet ( DMA_MODULE_ID index )
   Summary:
     Gets the priority scheme of the DMA channels.
   Description:
     This function gets the priority scheme of the DMA channels at the global level.
     This function is used in devices that do not have the per channel priority feature.
   Precondition:
     None.
   Parameters:
         None.
   Returns:
         - channelPriority - One of the supported priorities listed by DMA_CHANNEL_PRIORITY
   Example:
     <code>
         DMA_CHANNEL_PRIORITY channelPriority;
     channelPriority = PLIB_DMA_ChannelPriorityGet( DMA_ID_0 );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 DMA_CHANNEL_PRIORITY
   PLIB_DMA_ChannelPriorityGet (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXAutoEnable ( DMA_MODULE_ID index,
                                         DMA_CHANNEL channel )
   Summary:
     Channel is continuously enabled.
   Description:
     This function enables the channel continuously. The channel is not automatically
         disabled after a block transfer is complete.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_ChannelXAutoEnable( DMA_ID_0, DMA_CHANNEL_2 );
     </code>
   Remarks:
         This function implements an operation of the ChannelXAuto feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXAuto function in your application to determine
         whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXAutoEnable (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_DMA_ChannelXAutoIsEnabled ( DMA_MODULE_ID index,
                                             DMA_CHANNEL channel )
   Summary:
     Returns the channel automatic enable status.
   Description:
     This function returns the channel automatic enable status.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     - true      - Channel automatic enable is on
     - false     - Channel automatic enable is off
   Example:
     <code>
         bool ChAutoEnableStatus;
     ChAutoEnableStatus = PLIB_DMA_ChannelXAutoIsEnabled(DMA_ID_0, DMA_CHANNEL_2 );
     </code>
   Remarks:
         This function implements an operation of the ChannelXAuto feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXAuto function in your application to determine
         whether this feature is available.
 */

 bool
   PLIB_DMA_ChannelXAutoIsEnabled (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXAutoDisable ( DMA_MODULE_ID index,
                                         DMA_CHANNEL channel )
   Summary:
     Channel is disabled after a block transfer is complete.
   Description:
     This function disables a channel after a block transfer is complete.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_ChannelXAutoDisable( DMA_ID_0, DMA_CHANNEL_2 );
     </code>
   Remarks:
         This function implements an operation of the ChannelXAuto feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXAuto function in your application to determine
         whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXAutoDisable (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXChainEnable ( DMA_MODULE_ID index,
                                         DMA_CHANNEL channel )
   Summary:
     Channel chain feature is enabled.
   Description:
     This function enables the channel chain feature.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_ChannelXChainEnable( DMA_ID_0, DMA_CHANNEL_2 );
     </code>
   Remarks:
         This function implements an operation of the ChannelXChainEnbl feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXChainEnbl function in your application to determine
         whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXChainEnable (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_DMA_ChannelXChainIsEnabled ( DMA_MODULE_ID index,
                                             DMA_CHANNEL channel )
   Summary:
     Returns the chain status of the specified channel.
   Description:
     This function returns the chain status of the specified channel.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     - true      - The channel chain is on for this channel
     - false     - The channel chain is off for this channel
   Example:
     <code>
         bool ChchainStatus;
     ChchainStatus = PLIB_DMA_ChannelXChainIsEnabled( DMA_ID_0, DMA_CHANNEL_2 );
     </code>
   Remarks:
         This function implements an operation of the ChannelXChainEnbl feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXChainEnbl function in your application to determine
         whether this feature is available.
 */

 bool
   PLIB_DMA_ChannelXChainIsEnabled (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXChainDisable( DMA_MODULE_ID index,
                                         DMA_CHANNEL channel )
   Summary:
     Disables the channel chaining for the specified DMA channel.
   Description:
     This function disables the channel chaining for the specified DMA channel.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_ChannelXChainDisable( DMA_ID_0, DMA_CHANNEL_2 );
     </code>
   Remarks:
         This function implements an operation of the ChannelXChainEnbl feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXChainEnbl function in your application to determine
         whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXChainDisable (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXDisabledEnablesEvents ( DMA_MODULE_ID index,
                                                     DMA_CHANNEL channel )
   Summary:
     Channel start/abort events will be registered even if the channel is
         disabled.
   Description:
     This function will allow the channel register start/abort events even if the
     channel is disabled.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_ChannelXDisabledEnablesEvents ( DMA_ID_0, DMA_CHANNEL_2 );
     </code>
   Remarks:
         This function implements an operation of the ChannelXDisabled feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXDisabled function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXDisabledEnablesEvents (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXDisabledDisablesEvents ( DMA_MODULE_ID index,
                                                     DMA_CHANNEL channel )
   Summary:
     Channel start/abort events will be ignored even if the channel is
         disabled.
   Description:
     This function will allow the channel start/abort events to be ignored even if
     the channel is disabled.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_ChannelXDisabledDisablesEvents ( DMA_ID_0, DMA_CHANNEL_2 );
     </code>
   Remarks:
         This function implements an operation of the ChannelXDisabled feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXDisabled function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXDisabledDisablesEvents (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXEnable ( DMA_MODULE_ID index,
                                     DMA_CHANNEL channel )
   Summary:
     Enable the specified channel.
   Description:
     This function will enable the specified channel.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_ChannelXEnable ( DMA_ID_0, DMA_CHANNEL_2 );
     </code>
   Remarks:
         This function implements an operation of the ChannelX feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelX function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXEnable (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_DMA_ChannelXIsEnabled ( DMA_MODULE_ID index,
                                         DMA_CHANNEL channel )
   Summary:
     Return the enable status of the specified channel.
   Description:
     This function will return the enable status of the specified channel.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     - true      - The specified DMA channel is enabled
     - false     - The specified DMA channel is disabled
   Example:
     <code>
         bool chEnableStatus;
     chEnableStatus = PLIB_DMA_ChannelXIsEnabled ( DMA_ID_0, DMA_CHANNEL_2 );
     </code>
   Remarks:
         This function implements an operation of the ChannelX feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelX function in your application to automatically
         determine whether this feature is available.
 */

 bool
   PLIB_DMA_ChannelXIsEnabled (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXDisable ( DMA_MODULE_ID index,
                                     DMA_CHANNEL channel )
   Summary:
     Disable the specified channel.
   Description:
     This function will disable the specified channel.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_ChannelXDisable ( DMA_ID_0, DMA_CHANNEL_2 );
     </code>
   Remarks:
         This function implements an operation of the ChannelX feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelX function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXDisable (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXChainToLower( DMA_MODULE_ID index,
                                         DMA_CHANNEL channel )
   Summary:
     Chains the specified channel to a channel lower in natural priority.
   Description:
     This function will chain the specified channel to a channel lower in
         natural priority. CH3 will be enabled by a CH4 transfer complete.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_ChannelXChainToLower ( DMA_ID_0, DMA_CHANNEL_4 );
     </code>
   Remarks:
         This function implements an operation of the ChannelXChain feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXChain function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXChainToLower (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXChainToHigher ( DMA_MODULE_ID index,
                                             DMA_CHANNEL channel )
   Summary:
     Chains the specified channel to a channel higher in natural priority.
   Description:
     This function will chain the specified channel to a channel higher in
         natural priority. CH5 will be enabled by a CH4 transfer complete.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_ChannelXChainToHigher ( DMA_ID_0, DMA_CHANNEL_4 );
     </code>
   Remarks:
         This function implements an operation of the ChannelXChain feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXChain function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXChainToHigher (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXBusyActiveSet ( DMA_MODULE_ID index,
                                             DMA_CHANNEL channel )
   Summary:
     Sets the Busy bit to active.
   Description:
     This function sets the Busy bit to active, indicating the channel is active
         or has been enabled.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_ChannelXBusyActiveSet ( DMA_ID_0, DMA_CHANNEL_4 );
     </code>
   Remarks:
         This function implements an operation of the ChannelXBusy feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXBusy function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXBusyActiveSet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXBusyInActiveSet ( DMA_MODULE_ID index,
                                             DMA_CHANNEL channel )
   Summary:
     Sets the Busy bit to inactive.
   Description:
     This function sets the Busy bit to inactive, indicating the channel is inactive
         or has been disabled.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_ChannelXBusyInActiveSet ( DMA_ID_0, DMA_CHANNEL_4 );
     </code>
   Remarks:
         This function implements an operation of the ChannelXBusy feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXBusy function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXBusyInActiveSet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_DMA_ChannelXBusyIsBusy ( DMA_MODULE_ID index,
                                     DMA_CHANNEL channel )
   Summary:
     Returns the busy status of the specified channel.
   Description:
     This function returns the busy status of the specified channel.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     - true      - The channel is active or has been enabled
     - false     - The channel is inactive or has been disabled
   Example:
     <code>
         bool chBusyStatus;
     chBusyStatus = PLIB_DMA_ChannelXBusyIsBusy ( DMA_ID_0, DMA_CHANNEL_4 );
     </code>
   Remarks:
         This function implements an operation of the ChannelXBusy feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXBusy function in your application to automatically
         determine whether this feature is available.
 */

 bool
   PLIB_DMA_ChannelXBusyIsBusy (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXTransferDirectionSelect ( DMA_MODULE_ID index,
                                                     DMA_CHANNEL channel,
                                                     DMA_CHANNEL_TRANSFER_DIRECTION chTransferDirection )
   Summary:
     Selects the data transfer direction of the specified channel.
   Description:
     This function selects the data transfer direction of the specified channel.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
         chTransferDirection - The transfer direction indicated by DMA_CHANNEL_TRANSFER_DIRECTION
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_ChannelXTransferDirectionSelect (
                                 DMA_ID_0,
                                 DMA_CHANNEL_4,
                                 DMA_READ_FROM_MEMORY_WRITE_TO_PERIPHERAL );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 void
   PLIB_DMA_ChannelXTransferDirectionSelect (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ,
   DMA_CHANNEL_TRANSFER_DIRECTION chTransferDirection ) ;
 //******************************************************************************
 /* Function:
     DMA_CHANNEL_TRANSFER_DIRECTION PLIB_DMA_ChannelXTransferDirectionGet (
                                                     DMA_MODULE_ID index,
                                                     DMA_CHANNEL channel)
   Summary:
     Returns the data transfer direction of the specified channel.
   Description:
     This function returns the data transfer direction of the specified channel.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     - DMA_CHANNEL_TRANSFER_DIRECTION - The transfer direction indicated by the
                                         DMA_CHANNEL_TRANSFER_DIRECTION
   Example:
     <code>
         DMA_CHANNEL_TRANSFER_DIRECTION chTransferDirection;
     chTransferDirection = PLIB_DMA_ChannelXTransferDirectionGet (
                                                                 DMA_ID_0,
                                                                 DMA_CHANNEL_4 );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 DMA_CHANNEL_TRANSFER_DIRECTION
   PLIB_DMA_ChannelXTransferDirectionGet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXStartAddressOffsetSet( DMA_MODULE_ID index,
                                                     DMA_CHANNEL channel ,
                                                     uint16_t address,
                                                     DMA_ADDRESS_OFFSET_TYPE offset )
   Summary:
     Sets the primary/secondary start address (DPSRAM) offset to the value
     specified depending on the offset type specified for the specified channel.
   Description:
     This function sets the primary/secondary start address (DPSRAM) offset to the value
     specified depending on the offset type specified for the specified channel.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
         address - The primary/secondary DPSRAM start address offset
         offset - The type of the address offset (primary/secondary)
   Returns:
     None.
   Example:
     <code>
         uint16_t address = 0x100;
     PLIB_DMA_ChannelXStartAddressOffsetSet ( DMA_ID_0,
                                                 DMA_CHANNEL_4,
                                                 address,
                                                 DMA_ADDRESS_OFFSET_PRIMARY );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 void
   PLIB_DMA_ChannelXStartAddressOffsetSet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ,
   uint16_t address ,
   DMA_ADDRESS_OFFSET_TYPE offset ) ;
 //******************************************************************************
 /* Function:
     uint16_t PLIB_DMA_ChannelXStartAddressOffsetGet ( DMA_MODULE_ID index,
                                                         DMA_CHANNEL channel,
                                                         DMA_ADDRESS_OFFSET_TYPE offset)
   Summary:
     Gets the primary/secondary start address (DPSRAM) offset.
   Description:
     This function gets the primary/secondary start address (DPSRAM) offset.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
     offset - The type of the address offset (primary/secondary)
   Returns:
     - uint16_t  - The primary/secondary DPSRAM start address offset
   Example:
     <code>
         uint16_t addressOffsetA;
     addressOffsetA = PLIB_DMA_ChannelXStartAddressOffsetGet (
                                                     DMA_ID_0,
                                                     DMA_CHANNEL_4,
                                                     address,
                                                     DMA_ADDRESS_OFFSET_PRIMARY );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 uint16_t
   PLIB_DMA_ChannelXStartAddressOffsetGet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ,
   DMA_ADDRESS_OFFSET_TYPE offset ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXPeripheralAddressSet( DMA_MODULE_ID index,
                                                 DMA_CHANNEL channel ,
                                                     uint16_t peripheraladdress )
   Summary:
     Sets the peripheral address for the specified channel.
   Description:
     This function sets the peripheral address for the specified channel.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
         peripheraladdress - The peripheral address for the specified channel
   Returns:
     None.
   Example:
     <code>
         uint16_t peripheraladdress = 0x100;
     PLIB_DMA_ChannelXPeripheralAddressSet ( DMA_ID_0,
                                             DMA_CHANNEL_4,
                                             peripheraladdress );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 void
   PLIB_DMA_ChannelXPeripheralAddressSet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ,
   uint16_t peripheraladdress ) ;
 //******************************************************************************
 /* Function:
     uint16_t PLIB_DMA_ChannelXPeripheralAddressGet( DMA_MODULE_ID index,
                                                     DMA_CHANNEL channel )
   Summary:
     Gets the peripheral address configured for the specified channel.
   Description:
     This function gets the peripheral address configured for the specified channel.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     - uint16_t  - The peripheral address configured for the specified channel
   Example:
     <code>
         uint16_t peripheraladdress;
     peripheraladdress = PLIB_DMA_ChannelXPeripheralAddressGet ( DMA_ID_0,
                                                                 DMA_CHANNEL_4 );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 uint16_t
   PLIB_DMA_ChannelXPeripheralAddressGet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXTransferCountSet( DMA_MODULE_ID index,
                                             DMA_CHANNEL channel ,
                                                 uint16_t transferCount )
   Summary:
     Sets the DMA data transfer count for the specified channel.
   Description:
     This function sets the DMA data transfer count for the specified channel.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
         transferCount - The DMA transfer count for the channel
   Returns:
     None.
   Example:
     <code>
         uint16_t transferCount = 0x10;
     PLIB_DMA_ChannelXTransferCountSet ( DMA_ID_0,
                                         DMA_CHANNEL_4,
                                         transferCount );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 void
   PLIB_DMA_ChannelXTransferCountSet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ,
   uint16_t transferCount ) ;
 //******************************************************************************
 /* Function:
     uint16_t PLIB_DMA_ChannelXTransferCountGet( DMA_MODULE_ID index,
                                                 DMA_CHANNEL channel )
   Summary:
     Gets the DMA data transfer count that is programmed for the specified channel.
   Description:
     This function gets the DMA data transfer count that is programmed for the specified channel.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     - uint16_t  - The DMA transfer count for the channel
   Example:
     <code>
         uint16_t transferCount;
     transferCount = PLIB_DMA_ChannelXTransferCountGet ( DMA_ID_0,
                                                         DMA_CHANNEL_4 );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 uint16_t
   PLIB_DMA_ChannelXTransferCountGet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXSourceAddressModeSelect (
                                 DMA_MODULE_ID index,
                                 DMA_CHANNEL channel,
                                 DMA_SOURCE_ADDRESSING_MODE sourceAddressMode )
   Summary:
     Sets the source address mode of the specified channel.
   Description:
     This function sets the source address mode of the specified channel.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
         sourceAddressMode - One of the possible source addressing modes listed by
                               DMA_SOURCE_ADDRESSING_MODE
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_ChannelXSourceAddressModeSelect (
                                 DMA_ID_0,
                                 DMA_CHANNEL_4,
                                 DMA_ADDRESSING_SOURCE_INCREMENT_BASED_ON_SIZE );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 void
   PLIB_DMA_ChannelXSourceAddressModeSelect (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ,
   DMA_SOURCE_ADDRESSING_MODE sourceAddressMode ) ;
 //******************************************************************************
 /* Function:
     DMA_SOURCE_ADDRESSING_MODE PLIB_DMA_ChannelXSourceAddressModeGet (
                                                             DMA_MODULE_ID index,
                                                             DMA_CHANNEL channel )
   Summary:
     Gets the source address mode of the specified channel.
   Description:
     This function gets the source address mode of the specified channel.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     - DMA_SOURCE_ADDRESSING_MODE        - One of the possible source addressing modes
                                       listed by DMA_SOURCE_ADDRESSING_MODE
   Example:
     <code>
         DMA_SOURCE_ADDRESSING_MODE sourceAddressMode;
     sourceAddressMode = PLIB_DMA_ChannelXSourceAddressModeGet ( DMA_ID_0,
                                                                 DMA_CHANNEL_4 );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 DMA_SOURCE_ADDRESSING_MODE
   PLIB_DMA_ChannelXSourceAddressModeGet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXDestinationAddressModeSelect (
                                 DMA_MODULE_ID index,
                                 DMA_CHANNEL channel,
                                 DMA_DESTINATION_ADDRESSING_MODE destinationAddressMode )
   Summary:
     Sets the source address mode of the specified channel.
   Description:
     This function Sets the source address mode of the specified channel.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
         destinationAddressMode - One of the possible source addressing modes listed by
                                   DMA_DESTINATION_ADDRESSING_MODE
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_ChannelXDestinationAddressModeSelect (
                             DMA_ID_0,
                      DMA_CHANNEL_4,
                             DMA_ADDRESSING_DESTINATION_INCREMENT_BASED_ON_SIZE );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 void
   PLIB_DMA_ChannelXDestinationAddressModeSelect (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ,
   DMA_DESTINATION_ADDRESSING_MODE destinationAddressMode ) ;
 //******************************************************************************
 /* Function:
     DMA_DESTINATION_ADDRESSING_MODE PLIB_DMA_ChannelXDestinationAddressModeGet (
                                                             DMA_MODULE_ID index,
                                                             DMA_CHANNEL channel )
   Summary:
     Gets the source address mode of the specified channel.
   Description:
     This function gets the source address mode of the specified channel.
   Precondition:
     None.
   Parameters:
     channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     - destinationAddressMode - One of the possible source addressing modes listed by
                                DMA_DESTINATION_ADDRESSING_MODE
   Example:
     <code>
         DMA_SOURCE_ADDRESSING_MODE destinationAddressMode;
     destinationAddressMode = PLIB_DMA_ChannelXDestinationAddressModeGet (
                                                                 DMA_ID_0,
                                                                 DMA_CHANNEL_4 );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 DMA_DESTINATION_ADDRESSING_MODE
   PLIB_DMA_ChannelXDestinationAddressModeGet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXAddressModeSelect (
                                 DMA_MODULE_ID index,
                                 DMA_CHANNEL channel,
                                 DMA_CHANNEL_ADDRESSING_MODE channelAddressMode )
   Summary:
     Sets the channel address mode.
   Description:
     This function sets the channel address mode.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
         channelAddressMode - One of the possible channel addressing modes listed by
                               DMA_CHANNEL_ADDRESSING_MODE
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_ChannelXAddressModeSelect (
                         DMA_ID_0,
                         DMA_CHANNEL_4,
                         DMA_ADDRESSING_REGISTER_INDIRECT_WITH_POST_INCREMENT );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 void
   PLIB_DMA_ChannelXAddressModeSelect (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ,
   DMA_CHANNEL_ADDRESSING_MODE channelAddressMode ) ;
 //******************************************************************************
 /* Function:
     DMA_CHANNEL_ADDRESSING_MODE PLIB_DMA_ChannelXAddressModeGet (
                                                             DMA_MODULE_ID index,
                                                             DMA_CHANNEL channel )
   Summary:
     Gets the channel address mode.
   Description:
     This function gets the channel address mode.
   Precondition:
     None.
   Parameters:
     channel     - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     - channelAddressMode - One of the possible source addressing modes listed by
                            DMA_CHANNEL_ADDRESSING_MODE
   Example:
     <code>
         DMA_CHANNEL_ADDRESSING_MODE channelAddressMode;
     channelAddressMode = PLIB_DMA_ChannelXAddressModeGet ( DMA_ID_0,
                                                             DMA_CHANNEL_4 );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 DMA_CHANNEL_ADDRESSING_MODE
   PLIB_DMA_ChannelXAddressModeGet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: DMA Channel Event Configuration functions
 // *****************************************************************************
 // *****************************************************************************
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXTriggerEnable ( DMA_MODULE_ID index,
                                             DMA_CHANNEL channel,
                                             DMA_CHANNEL_TRIGGER_TYPE trigger )
   Summary:
     Enables the specified DMA channel trigger.
   Description:
     This function enables the specified DMA channel trigger.
   Precondition:
     None.
   Parameters:
     channel - One of the possible DMA channels listed by DMA_CHANNEL
     trigger - Type of trigger (transfer start/abort/pattern match abort)
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_ChannelXTriggerEnable ( DMA_ID_0,
                                         DMA_CHANNEL_4,
                                         DMA_CHANNEL_TRIGGER_TRANSFER_ABORT );
     </code>
   Remarks:
         This function implements an operation of the ChannelXTrigger feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXTrigger function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXTriggerEnable (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ,
   DMA_CHANNEL_TRIGGER_TYPE trigger ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_DMA_ChannelXTriggerIsEnabled( DMA_MODULE_ID index,
                                             DMA_CHANNEL channel,
                                             DMA_CHANNEL_TRIGGER_TYPE trigger )
   Summary:
     Returns the enable status of the specified DMA transfer/abort trigger.
   Description:
     This function returns the enable status of the specified DMA transfer/abort trigger.
   Precondition:
     None.
   Parameters:
     channel - One of the possible DMA channels listed by DMA_CHANNEL
     trigger - Type of trigger (transfer start/abort/pattern match abort)
   Returns:
     - true      - The specified trigger is enabled
     - false     - The specified trigger is disabled
   Example:
     <code>
         bool startTriggerstatus;
     startTriggerstatus = PLIB_DMA_ChannelXTriggerIsEnabled (
                                             DMA_ID_0,
                                             DMA_CHANNEL_4,
                                             DMA_CHANNEL_TRIGGER_TRANSFER_START );
     </code>
   Remarks:
         This function implements an operation of the ChannelXTrigger feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXTrigger function in your application to automatically
         determine whether this feature is available.
 */

 bool
   PLIB_DMA_ChannelXTriggerIsEnabled (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ,
   DMA_CHANNEL_TRIGGER_TYPE trigger ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXTriggerDisable ( DMA_MODULE_ID index,
                                             DMA_CHANNEL channel,
                                             DMA_CHANNEL_TRIGGER_TYPE trigger )
   Summary:
     Disables the DMA transfer abort via a matching interrupt (specified by the IRQ).
   Description:
     This function disables the DMA transfer abort via a matching interrupt
         (specified by the IRQ). The interrupt number IRQ is ignored and does not terminate
         a transfer.
   Precondition:
     None.
   Parameters:
     channel - One of the possible DMA channels listed by DMA_CHANNEL
     trigger - Type of trigger (transfer start/abort/pattern match abort)
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_ChannelXTriggerDisable ( DMA_ID_0,
                                         DMA_CHANNEL_4,
                                         DMA_CHANNEL_TRIGGER_PATTERN_MATCH_ABORT );
     </code>
   Remarks:
         This function implements an operation of the ChannelXTrigger feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXTrigger function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXTriggerDisable (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ,
   DMA_CHANNEL_TRIGGER_TYPE trigger ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXTriggerSourceNumberGet ( DMA_MODULE_ID index,
                  DMA_CHANNEL channel)
   Summary:
     Gets the source number for the DMA channel interrupts.
   Description:
     This function returns the interrupt source number for the specified
         DMA channel.
   Precondition:
     None.
   Parameters:
     channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_ChannelXTriggerSourceNumberGet ( DMA_ID_0,
              DMA_CHANNEL_4);
     </code>
   Remarks:
         This function implements an operation of the ChannelXTrigger feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXTrigger function in your application to automatically
         determine whether this feature is available.
 */

 DMA_CHANNEL_INT_SOURCE
   PLIB_DMA_ChannelXTriggerSourceNumberGet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXStartIRQSet ( DMA_MODULE_ID index,
                                         DMA_CHANNEL channel,
                                         DMA_TRIGGER_SOURCE IRQnum )
   Summary:
     Sets the IRQ to initiate the DMA transfer on the specified channel.
   Description:
     This function sets the IRQ to initiate the DMA transfer on the specified channel.
         (IRQ to start the channel transfer.)
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
         IRQnum - The IRQ number of the trigger source of type DMA_TRIGGER_SOURCE
   Returns:
     None.
   Example:
     <code>
         DMA_TRIGGER_SOURCE irq = DMA_TRIGGER_OUTPUT_COMPARE_1;
     PLIB_DMA_ChannelXStartIRQSet ( DMA_ID_0,
                                     DMA_CHANNEL_4,
                                     irq );
     </code>
   Remarks:
         This function implements an operation of the ChannelXStartIRQ feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXStartIRQ function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXStartIRQSet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ,
   DMA_TRIGGER_SOURCE IRQnum ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXAbortIRQSet ( DMA_MODULE_ID index,
                                         DMA_CHANNEL channel,
                                         DMA_TRIGGER_SOURCE IRQ )
   Summary:
     Sets the IRQ to abort the DMA transfer on the specified channel.
   Description:
     This function sets the IRQ to abort the DMA transfer on the specified channel.
         (IRQ to start the channel transfer.)
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
         IRQnum - The IRQ number of the trigger source of type DMA_TRIGGER_SOURCE
   Returns:
     None.
   Example:
     <code>
         DMA_TRIGGER_SOURCE irq = DMA_TRIGGER_TIMER_CORE;
     PLIB_DMA_ChannelXAbortIRQSet ( DMA_ID_0,
                                     DMA_CHANNEL_4,
                                     irq );
     </code>
   Remarks:
         This function implements an operation of the ChannelXAbortIRQ feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXAbortIRQ function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXAbortIRQSet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ,
   DMA_TRIGGER_SOURCE IRQ ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXDataSizeSelect ( DMA_MODULE_ID index,
                                             DMA_CHANNEL channel,
                                             DMA_CHANNEL_DATA_SIZE channelDataSize )
   Summary:
     Selects the data size for the specified channel.
   Description:
     This function selects the data size for the specified channel.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
         channelDataSize - One of the possible data sizes listed by DMA_CHANNEL_DATA_SIZE
   Returns:
     None.
   Example:
     <code>
         DMA_CHANNEL_DATA_SIZE channelDataSize = DMA_CHANNEL_DATA_8;
     PLIB_DMA_ChannelXDataSizeSelect ( DMA_ID_0,
                                         DMA_CHANNEL_4,
                                         channelDataSize );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 void
   PLIB_DMA_ChannelXDataSizeSelect (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ,
   DMA_CHANNEL_DATA_SIZE channelDataSize ) ;
 //******************************************************************************
 /* Function:
     DMA_CHANNEL_DATA_SIZE PLIB_DMA_ChannelXDataSizeGet ( DMA_MODULE_ID index,
                                                             DMA_CHANNEL channel )
   Summary:
     Returns the current data size for the specified channel.
   Description:
     This function returns the current data size for the specified channel.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
         - channelDataSize - One of the possible data sizes listed by
                               DMA_CHANNEL_DATA_SIZE
   Example:
     <code>
         DMA_CHANNEL_DATA_SIZE channelDataSize;
     channelDataSize = PLIB_DMA_ChannelXDataSizeGet( DMA_ID_0,
                                                     DMA_CHANNEL_4 );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 DMA_CHANNEL_DATA_SIZE
   PLIB_DMA_ChannelXDataSizeGet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXOperatingTransferModeSelect (
                                         DMA_MODULE_ID index,
                                         DMA_CHANNEL channel,
                                         DMA_TRANSFER_MODE channeltransferMode )
   Summary:
     Selects the transfer/operating mode for the specified channel.
   Description:
     This function selects the transfer/operating mode for the specified channel.
         (Transfer mode and operating mode are used interchangeably.)
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
         channeltransferMode - One of the possible operating/transfer modes listed by
                           DMA_TRANSFER_MODE
   Returns:
     None.
   Example:
     <code>
         DMA_TRANSFER_MODE channeltransferMode = DMA_MODE_REPEATED_CONTINUOUS;
     PLIB_DMA_ChannelXOperatingTransferModeSelect ( DMA_ID_0,
                                                     DMA_CHANNEL_4,
                                                     channeltransferMode );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 void
   PLIB_DMA_ChannelXOperatingTransferModeSelect (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ,
   DMA_TRANSFER_MODE channeltransferMode ) ;
 //******************************************************************************
 /* Function:
     DMA_TRANSFER_MODE PLIB_DMA_ChannelXOperatingTransferModeGet (
                                                             DMA_MODULE_ID index,
                                                             DMA_CHANNEL channel )
   Summary:
     Returns the current transfer/operating mode for the specified channel.
   Description:
     This function returns the current transfer/operating mode for the specified channel.
         (Transfer mode and operating mode are used interchangeably.)
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     - channeltransferMode       - One of the possible operating/transfer modes listed
                               by DMA_TRANSFER_MODE
   Example:
     <code>
         DMA_TRANSFER_MODE channeltransferMode;
     channeltransferMode = PLIB_DMA_ChannelXOperatingTransferModeGet (
                                                                 DMA_ID_0,
                                                                 DMA_CHANNEL_4 );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 DMA_TRANSFER_MODE
   PLIB_DMA_ChannelXOperatingTransferModeGet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXReloadEnable( DMA_MODULE_ID index,
                                         DMA_CHANNEL channel )
   Summary:
     Enables reloading of the address and count registers.
   Description:
     This function enables reloading of the address and count registers. The source,
         destination address, and the DMA count registers are reloaded to their previous
         values upon the start of the next operation.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_ChannelXReloadEnable ( DMA_ID_0,
                                     DMA_CHANNEL_4 );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 void
   PLIB_DMA_ChannelXReloadEnable (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_DMA_ChannelXReloadIsEnabled ( DMA_MODULE_ID index,
                                             DMA_CHANNEL channel )
   Summary:
     Returns the address and count registers reload enable status.
   Description:
     This function returns the address and count registers reload enable status.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     - true      - The address and count registers reload is enabled
     - false     - The address and count registers reload is disabled
   Example:
     <code>
         bool chAddressCountReloadStatus;
     chAddressCountReloadStatus = PLIB_DMA_ChannelXReloadIsEnabled (
                                                                 DMA_ID_0,
                                                                 DMA_CHANNEL_4 );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 bool
   PLIB_DMA_ChannelXReloadIsEnabled (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXReloadDisable ( DMA_MODULE_ID index,
                                             DMA_CHANNEL channel )
   Summary:
     Disables reloading of the address and count registers.
   Description:
     This function disables reloading of the address and count registers. The source, destination
         address, and the DMA count registers are not reloaded to their previous values upon
         the start of the next operation.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_ChannelXReloadDisable ( DMA_ID_0,
                                         DMA_CHANNEL_4 );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 void
   PLIB_DMA_ChannelXReloadDisable (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXNullWriteModeEnable ( DMA_MODULE_ID index,
                                                 DMA_CHANNEL channel )
   Summary:
     Enables the Null Write mode.
   Description:
     This function enables the Null Write mode. A dummy write is initiated to the
         source address for every write to the destination address.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_ChannelXNullWriteModeEnable ( DMA_ID_0,
                                             DMA_CHANNEL_4 );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 void
   PLIB_DMA_ChannelXNullWriteModeEnable (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_DMA_ChannelXNullWriteModeIsEnabled ( DMA_MODULE_ID index,
                                                     DMA_CHANNEL channel )
   Summary:
     Returns the enable status of the Null Write mode for the specified channel.
   Description:
     This function returns the enable status of the Null Write mode for the specified channel.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     - true      - Null write mode is enabled for this channel
     - false     - Null write mode is disabled for this channel
   Example:
     <code>
         bool chNullWriteStatus;
     chNullWriteStatus = PLIB_DMA_ChannelXNullWriteModeIsEnabled (
                                                                 DMA_ID_0,
                                                                 DMA_CHANNEL_4 );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 bool
   PLIB_DMA_ChannelXNullWriteModeIsEnabled (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXNullWriteModeDisable( DMA_MODULE_ID index,
                                                 DMA_CHANNEL channel )
   Summary:
     Disables the Null Write mode.
   Description:
     This function disables the Null Write mode. No dummy write is initiated.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_ChannelXNullWriteModeDisable ( DMA_ID_0,
                                             DMA_CHANNEL_4 );
     </code>
   Remarks:
     This feature is not available on all devices. Please refer to the specific
     device data sheet to determine availability.
 */

 void
   PLIB_DMA_ChannelXNullWriteModeDisable (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: DMA start/end functions
 // *****************************************************************************
 // *****************************************************************************
 //******************************************************************************
 /* Function:
     void PLIB_DMA_StartTransferSet ( DMA_MODULE_ID index,
                                     DMA_CHANNEL channel )
   Summary:
     Initiates transfer on the specified channel.
   Description:
     This function initiates transfer on the specified channel. This is a forced transfer
         controlled via software.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_StartTransferSet ( DMA_ID_0,
                                 DMA_CHANNEL_4 );
     </code>
   Remarks:
         This function implements an operation of the StartTransfer feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsStartTransfer function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_StartTransferSet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_AbortTransferSet ( DMA_MODULE_ID index,
                                     DMA_CHANNEL channel )
   Summary:
     Aborts transfer on the specified channel.
   Description:
     This function aborts transfer on the specified channel. This is a forced abort
         controlled via software.
   Precondition:
     None.
   Parameters:
         channel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_AbortTransferSet ( DMA_ID_0,
                                 DMA_CHANNEL_4 );
     </code>
   Remarks:
         This function implements an operation of the AbortTransfer feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsAbortTransfer function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_AbortTransferSet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: DMA General Configuration functions
 // *****************************************************************************
 // *****************************************************************************
 //******************************************************************************
 /* Function:
     void PLIB_DMA_BusyActiveSet ( DMA_MODULE_ID index )
   Summary:
     Sets the BUSY bit of the DMA controller.
   Description:
     This function sets the BUSY bit of the DMA controller. The DMA module is active.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_BusyActiveSet( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the Busy feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsBusy function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_BusyActiveSet (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_BusyActiveReset ( DMA_MODULE_ID index )
   Summary:
     Resets the BUSY bit of the DMA controller.
   Description:
     This function resets the BUSY bit of the DMA controller. The DMA module is
     disabled and is not actively transferring data.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_BusyActiveReset( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the Busy feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsBusy function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_BusyActiveReset (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_DMA_IsBusy ( DMA_MODULE_ID index )
   Summary:
     Gets the BUSY bit of the DMA controller.
   Description:
     This function gets the BUSY bit of the DMA controller.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     - true      - DMA module is active
     - false     - DMA module is disabled and is not actively transferring data
   Example:
     <code>
         bool dmaBusyStatus;
     dmaBusyStatus = PLIB_DMA_IsBusy( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the Busy feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsBusy function in your application to automatically
         determine whether this feature is available.
 */

 bool
   PLIB_DMA_IsBusy (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_SuspendEnable ( DMA_MODULE_ID index )
   Summary:
     DMA transfers are suspended to allow uninterrupted access by the CPU to the data bus.
   Description:
     This function suspends the DMA transfers to allow uninterrupted access
         by the CPU to the data bus.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_SuspendEnable( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the Suspend feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsSuspend function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_SuspendEnable (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_SuspendDisable ( DMA_MODULE_ID index )
   Summary:
     DMA suspend is disabled and the DMA module operates normally.
   Description:
     This function disables the DMA suspend. The DMA module continues to operate
         normally.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_SuspendDisable( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the Suspend feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsSuspend function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_SuspendDisable (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_DMA_SuspendIsEnabled ( DMA_MODULE_ID index )
   Summary:
     Returns the DMA suspend status.
   Description:
     This function returns the DMA suspend status.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     - true      - The DMA transfers are suspended
     - false     - The DMA operates normally
   Example:
     <code>
         bool dmaSuspendStatus;
     dmaSuspendStatus = PLIB_DMA_SuspendIsEnabled( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the Suspend feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsSuspend function in your application to automatically
         determine whether this feature is available.
 */

 bool
   PLIB_DMA_SuspendIsEnabled (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_StopInIdleEnable ( DMA_MODULE_ID index )
   Summary:
     DMA transfers are halted during Idle mode.
   Description:
     This function halts DMA transfers during Idle mode.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_StopInIdleEnable( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the StopInIdle feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsStopInIdle function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_StopInIdleEnable (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_StopInIdleDisable ( DMA_MODULE_ID index )
   Summary:
     DMA transfers continue during Idle mode.
   Description:
     This function causes DMA transfers to continue during Idle mode.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_StopInIdleDisable( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the StopInIdle feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsStopInIdle function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_StopInIdleDisable (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_Enable ( DMA_MODULE_ID index )
   Summary:
     DMA module is enabled.
   Description:
     This function enables the DMA module.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_Enable( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the EnableControl feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsEnableControl function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_Enable (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_DMA_IsEnabled ( DMA_MODULE_ID index )
   Summary:
     Returns the DMA module enable status.
   Description:
     This function returns the DMA module enable status.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     - true      - The DMA is enabled
     - false     - The DMA is disabled
   Example:
     <code>
     PLIB_DMA_IsEnabled( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the EnableControl feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsEnableControl function in your application to automatically
         determine whether this feature is available.
 */

 bool
   PLIB_DMA_IsEnabled (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_Disable ( DMA_MODULE_ID index )
   Summary:
     DMA module is disabled.
   Description:
     This function disables the DMA module.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_Disable( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the EnableControl feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsEnableControl function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_Disable (
   DMA_MODULE_ID index ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: DMA status functions
 // *****************************************************************************
 // *****************************************************************************
 //******************************************************************************
 /* Function:
     uint8_t PLIB_DMA_ChannelBitsGet ( DMA_MODULE_ID index )
   Summary:
     Returns the DMA channel bits.
   Description:
     This function returns the channel bits.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     - uint8_t   - DMA channel bits
   Example:
     <code>
         uint8_t dmaChBits;
     dmaChBits = PLIB_DMA_ChannelBitsGet( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the ChannelBits feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelBits function in your application to automatically
         determine whether this feature is available.
 */

 uint8_t
   PLIB_DMA_ChannelBitsGet (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_DMA_LastBusAccessIsRead ( DMA_MODULE_ID index )
   Summary:
     Returns true if the last DMA bus access was a read.
   Description:
     This function returns true if the last DMA bus access was a read.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     - true      - The last bus access was a read
     - false     - The last bus access was not a read
   Example:
     <code>
         bool dmaLastBusAccessType;
     dmaLastBusAccessType = PLIB_DMA_LastBusAccessIsRead( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the LastBusAccess feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsLastBusAccess function in your application to automatically
         determine whether this feature is available.
 */

 bool
   PLIB_DMA_LastBusAccessIsRead (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_DMA_LastBusAccessIsWrite ( DMA_MODULE_ID index )
   Summary:
     Returns true if the last DMA bus access was a write.
   Description:
     This function returns true if the last DMA bus access was a write operation.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     - true      - The last bus access was a write operation
     - false     - The last bus access was not a write operation
   Example:
     <code>
         bool dmaLastBusAccessType;
     dmaLastBusAccessType = PLIB_DMA_LastBusAccessIsWrite( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the LastBusAccess feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsLastBusAccess function in your application to automatically
         determine whether this feature is available.
 */

 bool
   PLIB_DMA_LastBusAccessIsWrite (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     uint32_t PLIB_DMA_RecentAddressAccessed ( DMA_MODULE_ID index )
   Summary:
     Returns the address of the most recent DMA access.
   Description:
     This function returns the address of the most recent DMA access.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     - uint32_t  - The most recent address accessed by the DMA
   Example:
     <code>
         uint32_t dmaLastAddressAccessed;
     dmaLastAddressAccessed = PLIB_DMA_RecentAddressAccessed( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the RecentAddress feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsRecentAddress function in your application to automatically
         determine whether this feature is available.
 */

 uint32_t
   PLIB_DMA_RecentAddressAccessed (
   DMA_MODULE_ID index ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: DMA Module CRC Feature Interface Functions
 // *****************************************************************************
 // *****************************************************************************
 //******************************************************************************
 /* Function:
     void PLIB_DMA_CRCChannelSelect( DMA_MODULE_ID index,
                                     DMA_CHANNEL channel )
   Summary:
     Assigns the CRC to the specified DMA channel.
   Description:
     This function assigns the CRC feature to the specified channel.
   Precondition:
     None.
   Parameters:
     channel     - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_CRCChannelSelect( DMA_ID_0,
                                 DMA_CHANNEL_5 );
     </code>
   Remarks:
         This function implements an operation of the CRCChannel feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsCRCChannel function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_CRCChannelSelect (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     DMA_CHANNEL PLIB_DMA_CRCChannelGet ( DMA_MODULE_ID index )
   Summary:
     Returns the current DMA channel to which the CRC is assigned.
   Description:
     This function returns the current DMA channel to which the CRC is assigned.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     crcChannel  - One of the possible DMA channels listed by DMA_CHANNEL
   Example:
     <code>
         DMA_CHANNEL crcChannel;
     crcChannel = PLIB_DMA_CRCChannelGet( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the CRCChannel feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsCRCChannel function in your application to automatically
         determine whether this feature is available.
 */

 DMA_CHANNEL
   PLIB_DMA_CRCChannelGet (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_CRCTypeSet ( DMA_MODULE_ID index,
                                 DMA_CRC_TYPE CRCType )
   Summary:
     Selects the DMA module CRC feature type.
   Description:
     This function selects the DMA module CRC feature type. The CRC feature will
         compute either the IP header checksum or the Linear Shift Feedback Register (LFSR)
         checksum.
   Precondition:
     None.
   Parameters:
     CRCType     - One of the possible CRC checksums listed by DMA_CRC_TYPE
   Returns:
     None.
   Example:
     <code>
     PLIB_DMA_CRCTypeSet(DMA_ID_0,
                         DMA_CRC_IP_HEADER );
     </code>
   Remarks:
         This function implements an operation of the CRCType feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsCRCType function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_CRCTypeSet (
   DMA_MODULE_ID index ,
   DMA_CRC_TYPE CRCType ) ;
 //******************************************************************************
 /* Function:
     DMA_CRC_TYPE PLIB_DMA_CRCTypeGet ( DMA_MODULE_ID index )
   Summary:
     Gets the current DMA module CRC feature type.
   Description:
     This function gets the DMA module CRC feature type. The CRC feature will
         compute either the IP header checksum or the Linear Shift Feedback Register (LFSR)
         checksum.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     - CRCType   - One of the possible CRC checksums listed by DMA_CRC_TYPE.
   Example:
     <code>
         DMA_CRC_TYPE CRCType;
     CRCType = PLIB_DMA_CRCTypeGet( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the CRCType feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsCRCType function in your application to automatically
         determine whether this feature is available.
 */

 DMA_CRC_TYPE
   PLIB_DMA_CRCTypeGet (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_CRCAppendModeEnable ( DMA_MODULE_ID index )
   Summary:
     Enables the CRC append mode.
   Description:
     This function enables the CRC append mode. The DMA transfers data from the source
         into the CRC, but not to the destination. When a block transfer completes, the
         DMA writes the calculated CRC value to the location specified by the CHxDSA register.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     None.
   Example:
     <code>
         PLIB_DMA_CRCAppendModeEnable( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the CRCAppendMode feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsCRCAppendMode function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_CRCAppendModeEnable (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_DMA_CRCAppendModeIsEnabled ( DMA_MODULE_ID index )
   Summary:
     Gets the enable status of the CRC append mode.
   Description:
     This function gets the enable status of the CRC append mode.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     - true      - CRC append mode is enabled
     - false     - CRC append mode is disabled
   Example:
     <code>
         bool DMAcrcAppendMode;
         DMAcrcAppendMode = PLIB_DMA_CRCAppendModeIsEnabled( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the CRCAppendMode feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsCRCAppendMode function in your application to automatically
         determine whether this feature is available.
 */

 bool
   PLIB_DMA_CRCAppendModeIsEnabled (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_CRCAppendModeDisable ( DMA_MODULE_ID index )
   Summary:
     Disables the CRC append mode.
   Description:
     This function disables the CRC append mode. The DMA transfers data from the
         source through the CRC obeying WBO (DMA_MODULE_ID index, write byte order)
     as it writes the data to the destination.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     None.
   Example:
     <code>
         PLIB_DMA_CRCAppendModeDisable( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the CRCAppendMode feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsCRCAppendMode function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_CRCAppendModeDisable (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_CRCEnable ( DMA_MODULE_ID index )
   Summary:
     Enables the DMA module CRC feature.
   Description:
     This function enables the DMA module CRC feature. The channel transfers are
         routed through the CRC.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     None.
   Example:
     <code>
         PLIB_DMA_CRCEnable( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the CRC feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsCRC function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_CRCEnable (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_DMA_CRCIsEnabled ( DMA_MODULE_ID index )
   Summary:
     Gets the enable status of the CRC feature.
   Description:
     This function gets the enable status of the CRC feature.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     - true      - The CRC feature is enabled
     - false     - The CRC feature is disabled
   Example:
     <code>
         bool DMAcrcStatus;
         DMAcrcStatus = PLIB_DMA_CRCIsEnabled( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the CRC feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsCRC function in your application to automatically
         determine whether this feature is available.
 */

 bool
   PLIB_DMA_CRCIsEnabled (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_CRCDisable ( DMA_MODULE_ID index )
   Summary:
     Disables the DMA module CRC feature.
   Description:
     This function disables the DMA module CRC feature. The channel transfers proceed
         normally.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     None.
   Example:
     <code>
         PLIB_DMA_CRCDisable( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the CRC feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsCRC function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_CRCDisable (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_CRCPolynomialLengthSet ( DMA_MODULE_ID index,
                                             uint8_t polyLength )
   Summary:
     Selects the polynomial length.
   Description:
     This function Selects the polynomial length.
   Precondition:
     None.
   Parameters:
     polyLength  - Polynomial length
   Returns:
     None.
   Example:
     <code>
         uint8_t polyLength = 0x2;
     PLIB_DMA_CRCPolynomialLengthSet( DMA_ID_0, polyLength );
     </code>
   Remarks:
         This function implements an operation of the CRCPolynomialLength feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsCRCPolynomialLength function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_CRCPolynomialLengthSet (
   DMA_MODULE_ID index ,
   uint8_t polyLength ) ;
 //******************************************************************************
 /* Function:
     uint8_t PLIB_DMA_CRCPolynomialLengthGet ( DMA_MODULE_ID index )
   Summary:
     Gets the current polynomial length.
   Description:
     This function gets the current polynomial length.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     - uint8_t   - Polynomial length
   Example:
     <code>
         uint8_t polyLength;
     polyLength = PLIB_DMA_CRCPolynomialLengthGet( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the CRCPolynomialLength feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsCRCPolynomialLength function in your application to automatically
         determine whether this feature is available.
 */

 uint8_t
   PLIB_DMA_CRCPolynomialLengthGet (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_CRCBitOrderSelect ( DMA_MODULE_ID index,
                                         DMA_CRC_BIT_ORDER bitOrder )
   Summary:
     Selects the bit order for checksum calculation.
   Description:
     This function selects the bit order for checksum calculation.
   Precondition:
     None.
   Parameters:
     bitOrder - Specifies the bit order for CRC calculation
   Returns:
     None.
   Example:
     <code>
         PLIB_DMA_CRCBitOrderSelect ( DMA_ID_0,DMA_CRC_BIT_ORDER_LSB );
     </code>
   Remarks:
         This function implements an operation of the CRCBitOrder feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsCRCBitOrder function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_CRCBitOrderSelect (
   DMA_MODULE_ID index ,
   DMA_CRC_BIT_ORDER bitOrder ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_CRCWriteByteOrderAlter ( DMA_MODULE_ID index )
   Summary:
     The source data is written to the destination reordered as defined by the
         BYTO<1:0> bits.
   Description:
     This function enables byte order alteration as specified by the BYTO<1:0> bits.
         The source data is written to the destination reordered as defined by the
         BYTO<1:0> bits.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     None.
   Example:
     <code>
         PLIB_DMA_CRCWriteByteOrderAlter ( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the CRCWriteByteOrder feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsCRCWriteByteOrder function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_CRCWriteByteOrderAlter (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_CRCWriteByteOrderMaintain ( DMA_MODULE_ID index )
   Summary:
     The source data is written to the destination unaltered.
   Description:
     This function disables byte order alteration. The source data is written
         to the destination unaltered.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     None.
   Example:
     <code>
         PLIB_DMA_CRCWriteByteOrderMaintain ( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the CRCWriteByteOrder feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsCRCWriteByteOrder function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_CRCWriteByteOrderMaintain (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_CRCByteOrderSelect ( DMA_MODULE_ID index,
                                         DMA_CRC_BYTE_ORDER byteOrder )
   Summary:
     Selects the byte order.
   Description:
     This function selects the byte order.
   Precondition:
     The WBO bit must be set to use this function.
   Parameters:
     byteOrder   - One of the possible byte orders specified by DMA_CRC_BYTE_ORDER
   Returns:
     None.
   Example:
     <code>
         PLIB_DMA_CRCByteOrderSelect ( DMA_ID_0,
                                     DMA_CRC_SWAP_HALF_WORD_ON_WORD_BOUNDARY );
     </code>
   Remarks:
         This function implements an operation of the CRCByteOrder feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsCRCByteOrder function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_CRCByteOrderSelect (
   DMA_MODULE_ID index ,
   DMA_CRC_BYTE_ORDER byteOrder ) ;
 //******************************************************************************
 /* Function:
     DMA_CRC_BYTE_ORDER PLIB_DMA_CRCByteOrderGet ( DMA_MODULE_ID index )
   Summary:
     Gets the current byte order selected by the DMA module CRC feature.
   Description:
     This function gets the current byte order selected by the DMA module CRC feature.
   Precondition:
     The WBO bit must be set to use this function.
   Parameters:
     None.
   Returns:
     - byteOrder - One of the possible byte orders specified by DMA_CRC_BYTE_ORDER
   Example:
     <code>
         DMA_CRC_BYTE_ORDER byteOrder;
         byteOrder = PLIB_DMA_CRCByteOrderGet ( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the CRCByteOrder feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsCRCByteOrder function in your application to automatically
         determine whether this feature is available.
 */

 DMA_CRC_BYTE_ORDER
   PLIB_DMA_CRCByteOrderGet (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     uint32_t PLIB_DMA_CRCDataRead ( DMA_MODULE_ID index )
   Summary:
     Reads the contents of the DMA CRC data register.
   Description:
     This function reads the contents of the DMA CRC data register.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     - uint32_t  - 32-bit CRC data
     The CRC data (16-bit, 32-bit) is device-specific. Please refer to the specific
     device data sheet to determine availability.
   Example:
     <code>
         uint32_t DMACRCdata;
         DMACRCdata = PLIB_DMA_CRCDataRead ( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the CRCData feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsCRCData function in your application to automatically
         determine whether this feature is available.
 */

 uint32_t
   PLIB_DMA_CRCDataRead (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_CRCDataWrite ( DMA_MODULE_ID index,
                                     uint32_t DMACRCdata )
   Summary:
     Writes the contents of the DMA CRC data register with the specified data.
   Description:
     This function writes the contents of the DMA CRC data register.
   Precondition:
     None.
   Parameters:
     - DMACRCdata        - 32-bit CRC data
     The CRC data (16-bit, 32-bit) is device-specific. Please refer to the specific
     device data sheet to determine availability.
   Returns:
     None.
   Example:
     <code>
         uint32_t DMACRCdata = 0x0E0E0E;
         PLIB_DMA_CRCDataWrite ( DMA_ID_0, DMACRCdata );
     </code>
   Remarks:
         This function implements an operation of the CRCData feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsCRCData function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_CRCDataWrite (
   DMA_MODULE_ID index ,
   uint32_t DMACRCdata ) ;
 //******************************************************************************
 /* Function:
     uint32_t PLIB_DMA_CRCXOREnableGet ( DMA_MODULE_ID index )
   Summary:
     Reads the CRC XOR register.
   Description:
     This function reads the CRC XOR register.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     - uint32_t  - 32-bit CRC XOR enable mask data
     The CRC data (16-bit, 32-bit) is device-specific. Please refer to the specific
     device data sheet to determine availability.
   Example:
     <code>
         uint32_t DMACRCXORdata;
         DMACRCXORdata = PLIB_DMA_CRCXOREnableGet ( DMA_ID_0 );
     </code>
   Remarks:
         This function implements an operation of the CRCXOREnable feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsCRCXOREnable function in your application to automatically
         determine whether this feature is available.
 */

 uint32_t
   PLIB_DMA_CRCXOREnableGet (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_CRCXOREnableSet ( DMA_MODULE_ID index,
                                     uint32_t DMACRCXOREnableMask )
   Summary:
     Writes to the CRC XOR enable register as per the specified enable mask.
   Description:
     This function writes to the CRC XOR enable register as per the specified
         enable mask. Each enabled bit will be taken as input to the shift register.
   Precondition:
     None.
   Parameters:
     - DMACRCXOREnableMask       - 32-bit CRC XOR enable mask data
     The CRC data (16-bit, 32-bit) is device-specific. Please refer to the specific
     device data sheet to determine availability.
   Returns:
     None.
   Example:
     <code>
         uint32_t DMACRCXOREnableMask = 0x05EFFFFF;
         PLIB_DMA_CRCXOREnableSet ( DMA_ID_0, DMACRCXOREnableMask );
     </code>
   Remarks:
         This function implements an operation of the CRCXOREnable feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsCRCXOREnable function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_CRCXOREnableSet (
   DMA_MODULE_ID index ,
   uint32_t DMACRCXOREnableMask ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: DMA Address control Interface functions
 // *****************************************************************************
 // *****************************************************************************
 //******************************************************************************
 /* Function:
     uint32_t PLIB_DMA_ChannelXSourceStartAddressGet ( DMA_MODULE_ID index,
                                                         DMA_CHANNEL dmaChannel )
   Summary:
     Reads the source start address configured for the specified channel.
   Description:
     This function reads the source start address configured for the specified
         channel.
   Precondition:
     None.
   Parameters:
     dmaChannel  - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     - uint32_t  - The source start address configured for this channel
   Example:
     <code>
         DMA_CHANNEL spiDMAChannel = DMA_CHANNEL_2;
         uint32_t SourceStartAddress;
         SourceStartAddress = PLIB_DMA_ChannelXSourceStartAddressGet(DMA_ID_0,
                                                                 spiDMAChannel );
     </code>
   Remarks:
         This function implements an operation of the ChannelXSourceStartAddress feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXSourceStartAddress function in your application to automatically
         determine whether this feature is available.
 */

 uint32_t
   PLIB_DMA_ChannelXSourceStartAddressGet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL dmaChannel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXSourceStartAddressSet ( DMA_MODULE_ID index,
                                                     DMA_CHANNEL dmaChannel,
                     uint32_t sourceStartAddress)
   Summary:
     Writes the specified source start address into the register
         corresponding to the specified channel.
   Description:
     This function writes the specified Source start address into the register
     corresponding to the specified channel.
   Precondition:
     None.
   Parameters:
     dmaChannel   - One of the possible DMA channels listed by DMA_CHANNEL
         sourceStartAddress - The source start address
   Returns:
     None.
   Example:
     <code>
         DMA_CHANNEL spiDMAChannel = DMA_CHANNEL_2;
         uint32_t sourceStartAddress = 0x00FDEA00;
         PLIB_DMA_ChannelXSourceStartAddressSet ( DMA_ID_0,
                                                 spiDMAChannel,
                                                 sourceStartAddress );
     </code>
   Remarks:
         This function implements an operation of the ChannelXSourceStartAddress feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXSourceStartAddress function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXSourceStartAddressSet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL dmaChannel ,
   uint32_t sourceStartAddress ) ;
 //******************************************************************************
 /* Function:
     uint32_t PLIB_DMA_ChannelXDestinationStartAddressGet ( DMA_MODULE_ID index,
                                                             DMA_CHANNEL dmaChannel )
   Summary:
     Reads the destination start address configured for the specified channel.
   Description:
     This function reads the destination start address configured for the specified
         channel.
   Precondition:
     None.
   Parameters:
     dmaChannel  - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     - uint32_t  - The destination start address configured for this channel
   Example:
     <code>
         DMA_CHANNEL spiDMAChannel = DMA_CHANNEL_2;
         uint32_t DestinationStartAddress;
         DestinationStartAddress = PLIB_DMA_ChannelXDestinationStartAddressGet (
                                                                 DMA_ID_0,
                                                                 spiDMAChannel );
     </code>
   Remarks:
         This function implements an operation of the ChannelXDestinationStartAddress feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXDestinationStartAddress function in your application to automatically
         determine whether this feature is available.
 */

 uint32_t
   PLIB_DMA_ChannelXDestinationStartAddressGet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL dmaChannel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXDestinationStartAddressSet (
                                             DMA_MODULE_ID index,
                                             DMA_CHANNEL dmaChannel,
                   uint32_t destinationStartAddress)
   Summary:
     Writes the specified destination start address into the register corresponding to
     the specified channel.
   Description:
     This function writes the specified destination start address into the register
     corresponding to the specified channel.
   Precondition:
     None.
   Parameters:
     dmaChannel   - One of the possible DMA channels listed by DMA_CHANNEL
         destinationStartAddress - The destination start address
   Returns:
     None.
   Example:
     <code>
         DMA_CHANNEL spiDMAChannel = DMA_CHANNEL_2;
         uint32_t destinationStartAddress = 0x00FDEA00;
         PLIB_DMA_ChannelXDestinationStartAddressSet( DMA_ID_0,
                                                     spiDMAChannel,
                                                     destinationStartAddress );
     </code>
   Remarks:
         This function implements an operation of the ChannelXDestinationStartAddress feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXDestinationStartAddress function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXDestinationStartAddressSet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL dmaChannel ,
   uint32_t destinationStartAddress ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: DMA Data control Interface functions
 // *****************************************************************************
 // *****************************************************************************
 //******************************************************************************
 /* Function:
     uint16_t PLIB_DMA_ChannelXSourceSizeGet ( DMA_MODULE_ID index,
                                                 DMA_CHANNEL dmaChannel )
   Summary:
     Reads the source size configured for the specified channel.
   Description:
     This function reads the source size configured for the specified
         channel.
   Precondition:
     None.
   Parameters:
     dmaChannel  - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     - uint16_t  - The Source size configured (in bytes) for this channel.
     The source size (8-bit, 16-bit) is device-specific. Please refer to the specific
     device data sheet to determine availability.
   Example:
     <code>
         DMA_CHANNEL spiDMAChannel = DMA_CHANNEL_2;
         uint16_t sourceSize;
         sourceSize = PLIB_DMA_ChannelXSourceSizeGet ( DMA_ID_0,
                                                     spiDMAChannel );
     </code>
   Remarks:
         This function implements an operation of the ChannelXSourceSize feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXSourceSize function in your application to automatically
         determine whether this feature is available.
 */

 uint16_t
   PLIB_DMA_ChannelXSourceSizeGet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL dmaChannel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXSourceSizeSet ( DMA_MODULE_ID index,
                                             DMA_CHANNEL dmaChannel,
                      uint16_t sourceSize)
   Summary:
     Writes the specified source size into the register corresponding
         to the specified channel.
   Description:
     This function writes the specified source size into the register
         corresponding to the specified channel.
   Precondition:
     None.
   Parameters:
     dmaChannel  - One of the possible DMA channels listed by DMA_CHANNEL
         sourceSize - The source size. The source size (8-bit, 16-bit) is
                       device-specific. Please refer to the specific device data
              sheet to determine availability.
   Returns:
     None.
   Example:
     <code>
         DMA_CHANNEL spiDMAChannel = DMA_CHANNEL_2;
         uint16_t sourceSize = 0xA00;
         PLIB_DMA_ChannelXSourceSizeSet ( DMA_ID_0,
                                         spiDMAChannel,
                                         sourceSize );
     </code>
   Remarks:
         This function implements an operation of the ChannelXSourceSize feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXSourceSize function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXSourceSizeSet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL dmaChannel ,
   uint16_t sourceSize ) ;
 //******************************************************************************
 /* Function:
     uint16_t PLIB_DMA_ChannelXDestinationSizeGet ( DMA_MODULE_ID index,
                                                     DMA_CHANNEL dmaChannel )
   Summary:
     Reads the destination size configured for the specified channel.
   Description:
     This function reads the destination size configured for the specified
         channel.
   Precondition:
     None.
   Parameters:
     dmaChannel  - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     - uint16_t  - The destination size configured (in bytes) for this channel.
     The destination size (8-bit, 16-bit) is device-specific. Please refer to the specific
     device data sheet to determine availability.
   Example:
     <code>
         DMA_CHANNEL spiDMAChannel = DMA_CHANNEL_2;
         uint16_t DestinationSize;
         DestinationSize = PLIB_DMA_ChannelXDestinationSizeGet ( DMA_ID_0,
                                                             spiDMAChannel );
     </code>
   Remarks:
         This function implements an operation of the ChannelXDestinationSize feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXDestinationSize function in your application to automatically
         determine whether this feature is available.
 */

 uint16_t
   PLIB_DMA_ChannelXDestinationSizeGet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL dmaChannel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXDestinationSizeSet ( DMA_MODULE_ID index,
                                                 DMA_CHANNEL dmaChannel,
                                                 uint16_t destinationSize)
   Summary:
     Writes the specified destination size into the register corresponding
         to the specified channel.
   Description:
     This function writes the specified destination size into the register
         corresponding to the specified channel.
   Precondition:
     None.
   Parameters:
     dmaChannel   - One of the possible DMA channels listed by DMA_CHANNEL
         destinationSize - The destination size. The destination size (8-bit, 16-bit)
                       is device-specific. Please refer to the specific device
               data sheet to determine availability.)
   Returns:
     None.
   Example:
     <code>
         DMA_CHANNEL spiDMAChannel = DMA_CHANNEL_2;
         uint16_t destinationSize = 0xA00;
         PLIB_DMA_ChannelXDestinationSizeSet( DMA_ID_0, spiDMAChannel, destinationSize );
     </code>
   Remarks:
         This function implements an operation of the ChannelXDestinationSize feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXDestinationSize function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXDestinationSizeSet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL dmaChannel ,
   uint16_t destinationSize ) ;
 //******************************************************************************
 /* Function:
     uint16_t PLIB_DMA_ChannelXSourcePointerGet ( DMA_MODULE_ID index,
                                                 DMA_CHANNEL dmaChannel )
   Summary:
     Reads the current byte of the source being pointed to for the specified channel.
   Description:
     This function reads the current byte of the source being pointed to for the
         specified channel.
   Precondition:
     None.
   Parameters:
     dmaChannel  - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     - uint16_t  - The source byte being pointed to for this channel.
     The source pointer (8-bit, 16-bit) is device-specific. Please refer to the specific
     device data sheet to determine availability.
   Example:
     <code>
         DMA_CHANNEL spiDMAChannel = DMA_CHANNEL_2;
         uint16_t sourcebyte;
         sourcebyte = PLIB_DMA_ChannelXSourcePointerGet ( DMA_ID_0, spiDMAChannel );
     </code>
   Remarks:
         This function implements an operation of the ChannelXSourcePointer feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXSourcePointer function in your application to automatically
         determine whether this feature is available.
 */

 uint16_t
   PLIB_DMA_ChannelXSourcePointerGet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL dmaChannel ) ;
 //******************************************************************************
 /* Function:
     uint16_t PLIB_DMA_ChannelXDestinationPointerGet ( DMA_MODULE_ID index,
                                                     DMA_CHANNEL dmaChannel )
   Summary:
     Reads the current byte of the destination being pointed to for the specified channel.
   Description:
     This function reads the current byte of the destination being pointed to for the
         specified channel.
   Precondition:
     None.
   Parameters:
     dmaChannel  - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     - uint16_t  - The destination byte being pointed to for this channel.
     The destination pointer (8-bit, 16-bit) is device-specific. Please refer to the specific
     device data sheet to determine availability.
   Example:
     <code>
         DMA_CHANNEL spiDMAChannel = DMA_CHANNEL_2;
         uint16_t destinationbyte;
         destinationbyte = PLIB_DMA_ChannelXDestinationPointerGet ( DMA_ID_0,
                                                             spiDMAChannel );
     </code>
   Remarks:
         This function implements an operation of the ChannelXDestinationPointer feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXDestinationPointer function in your application to automatically
         determine whether this feature is available.
 */

 uint16_t
   PLIB_DMA_ChannelXDestinationPointerGet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL dmaChannel ) ;
 //******************************************************************************
 /* Function:
     uint16_t PLIB_DMA_ChannelXCellSizeGet ( DMA_MODULE_ID index,
                                             DMA_CHANNEL dmaChannel )
   Summary:
     Reads the cell size (in bytes) configured for the specified channel.
   Description:
     This function reads the cell size (in bytes) configured for the specified
         channel.
   Precondition:
     None.
   Parameters:
     dmaChannel  - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     - uint16_t  - The cell size configured (in bytes) for this channel
     The cell size (8-bit, 16-bit) is device-specific. Please refer to the specific
     device data sheet to determine availability.
   Example:
     <code>
         DMA_CHANNEL spiDMAChannel = DMA_CHANNEL_2;
         uint16_t cellSize;
         cellSize = PLIB_DMA_ChannelXCellSizeGet ( DMA_ID_0,
                                                 spiDMAChannel );
     </code>
   Remarks:
         This function implements an operation of the ChannelXCellSize feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXCellSize function in your application to automatically
         determine whether this feature is available.
 */

 uint16_t
   PLIB_DMA_ChannelXCellSizeGet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL dmaChannel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXCellSizeSet ( DMA_MODULE_ID index,
                                         DMA_CHANNEL dmaChannel,
                  uint16_t cellSize)
   Summary:
     Writes the specified cell size into the register corresponding
         to the specified channel.
   Description:
     This function writes the specified cell size into the register
         corresponding to the specified channel.
   Precondition:
     None.
   Parameters:
     dmaChannel  - One of the possible DMA channels listed by DMA_CHANNEL
     cellSize    - The cell size in bytes. The cell size (8-bit, 16-bit) is
                       device-specific. Please refer to the specific device data
              sheet to determine availability.)
   Returns:
     None.
   Example:
     <code>
         DMA_CHANNEL spiDMAChannel = DMA_CHANNEL_2;
         uint16_t cellSize = 0x10;
         PLIB_DMA_ChannelXCellSizeSet ( DMA_ID_0, spiDMAChannel, cellSize );
     </code>
   Remarks:
         This function implements an operation of the ChannelXCellSize feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXCellSize function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXCellSizeSet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL dmaChannel ,
   uint16_t CellSize ) ;
 //******************************************************************************
 /* Function:
     uint16_t PLIB_DMA_ChannelXCellProgressPointerGet ( DMA_MODULE_ID index,
                                                     DMA_CHANNEL dmaChannel )
   Summary:
     Returns the number of bytes transferred since the last event.
   Description:
     This function returns the number of bytes transferred since the last event.
   Precondition:
     None.
   Parameters:
     dmaChannel  - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     - uint16_t  - The number of bytes transferred since the last event.
     The cell progress pointer (8-bit, 16-bit) is device-specific. Please refer to
         the specific device data sheet to determine availability.
   Example:
     <code>
         DMA_CHANNEL spiDMAChannel = DMA_CHANNEL_2;
         uint16_t CellProgress;
         CellProgress = PLIB_DMA_ChannelXCellProgressPointerGet ( DMA_ID_0,
                                                             spiDMAChannel );
     </code>
   Remarks:
         This function implements an operation of the ChannelXCellProgressPointer feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXCellProgressPointer function in your application to automatically
         determine whether this feature is available.
 */

 uint16_t
   PLIB_DMA_ChannelXCellProgressPointerGet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL dmaChannel ) ;
 //******************************************************************************
 /* Function:
     uint16_t PLIB_DMA_ChannelXPatternDataGet ( DMA_MODULE_ID index,
                                                 DMA_CHANNEL dmaChannel )
   Summary:
     Returns the pattern matching (for DMA abort) data programmed for the specified
         channel.
   Description:
     This function returns pattern matching (for DMA abort) data programmed for
         the specified channel.
     (The size of pattern matching data(8-bit, 16-bit) is device-specific. Please refer to
         the specific device data sheet to determine availability.)
   Precondition:
     None.
   Parameters:
     dmaChannel  - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     - uint16_t  - The pattern matching data programmed for the current channel.
     The size of pattern matching data(8-bit, 16-bit) is device-specific. Please refer to
         the specific device data sheet to determine availability.
   Example:
     <code>
         DMA_CHANNEL spiDMAChannel = DMA_CHANNEL_2;
         uint16_t patternData;
         patternData = PLIB_DMA_ChannelXPatternDataGet ( DMA_ID_0, spiDMAChannel );
     </code>
   Remarks:
         This function implements an operation of the ChannelXPatternData feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXPatternData function in your application to automatically
         determine whether this feature is available.
 */

 uint16_t
   PLIB_DMA_ChannelXPatternDataGet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL dmaChannel ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXPatternDataSet ( DMA_MODULE_ID index,
                                             DMA_CHANNEL dmaChannel,
                      uint16_t patternData)
   Summary:
     Writes the specified pattern matching data (for DMA abort) into the register
         corresponding to the specified channel.
   Description:
     This function writes the specified pattern matching data (for DMA abort) into the
         register corresponding to the specified channel.
     (The size of pattern matching data(8-bit, 16-bit) is device-specific. Please refer to
         the specific device data sheet to determine availability.)
   Precondition:
     None.
   Parameters:
     dmaChannel  - One of the possible DMA channels listed by DMA_CHANNEL
     patternData - The pattern matching DATA programmed for the current channel
     (The size of pattern matching data(8-bit, 16-bit) is device-specific. Please refer to
         the specific device data sheet to determine availability.)
   Returns:
     None.
   Example:
     <code>
         DMA_CHANNEL spiDMAChannel = DMA_CHANNEL_2;
         uint16_t patternData = '\0';
         PLIB_DMA_ChannelXPatternDataSet ( DMA_ID_0, spiDMAChannel, patternData );
     </code>
   Remarks:
         This function implements an operation of the ChannelXPatternData feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXPatternData function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXPatternDataSet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL dmaChannel ,
   uint16_t patternData ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: DMA Interrupt Control Interface functions
 // *****************************************************************************
 // *****************************************************************************
 //******************************************************************************
 /* Function:
     bool PLIB_DMA_ChannelXINTSourceFlagGet ( DMA_MODULE_ID index,
                                                 DMA_CHANNEL dmaChannel,
                                                 DMA_INT_TYPE dmaINTSource )
   Summary:
     Returns the status of the interrupt flag of the specified DMA interrupt source
         for the specified channel.
   Description:
     This function returns the status of the interrupt flag of the specified DMA interrupt
         source for the specified channel.
   Precondition:
     None.
   Parameters:
         dmaChannel - One of the possible DMA channels listed by DMA_CHANNEL
         dmaINTSource - One of the DMA interrupt sources specified by DMA_INT_TYPE
   Returns:
     - true      - The interrupt flag is set
     - false     - The interrupt flag is not set
   Example:
     <code>
         DMA_CHANNEL spiDMAChannel = DMA_CHANNEL_2;
         bool AddressErrorINTStatus;
         AddressErrorINTStatus = PLIB_DMA_ChannelXINTSourceFlagGet (
                                                         DMA_ID_0,
                                                         spiDMAChannel,
                                                         DMA_INT_ADDRESS_ERROR );
     </code>
   Remarks:
         This function implements an operation of the ChannelXINTSourceFlag feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXINTSourceFlag function in your application to automatically
         determine whether this feature is available.
 */

 bool
   PLIB_DMA_ChannelXINTSourceFlagGet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL dmaChannel ,
   DMA_INT_TYPE dmaINTSource ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXINTSourceFlagSet ( DMA_MODULE_ID index,
                                                 DMA_CHANNEL dmaChannel,
                                                 DMA_INT_TYPE dmaINTSource )
   Summary:
     Sets the interrupt flag of the specified DMA interrupt source for the specified channel.
   Description:
     This function sets the interrupt flag of the specified DMA interrupt source for
         the specified channel.
   Precondition:
     None.
   Parameters:
         dmaChannel - One of the possible DMA channels listed by DMA_CHANNEL
         dmaINTSource - One of the DMA interrupt sources specified by DMA_INT_TYPE
   Returns:
     None.
   Example:
     <code>
         DMA_CHANNEL spiDMAChannel = DMA_CHANNEL_2;
         PLIB_DMA_ChannelXINTSourceFlagSet ( DMA_ID_0,
                                         spiDMAChannel,
                                         DMA_INT_ADDRESS_ERROR );
     </code>
   Remarks:
         This function implements an operation of the ChannelXINTSourceFlag feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXINTSourceFlag function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXINTSourceFlagSet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL dmaChannel ,
   DMA_INT_TYPE dmaINTSource ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXINTSourceFlagClear ( DMA_MODULE_ID index,
                                                 DMA_CHANNEL dmaChannel,
                                                 DMA_INT_TYPE dmaINTSource )
   Summary:
     Clears the interrupt flag of the specified DMA interrupt source
         for the specified channel.
   Description:
     This function clears the interrupt flag of the specified DMA interrupt source
         for the specified channel.
   Precondition:
     None.
   Parameters:
     dmaChannel   - One of the possible DMA channels listed by DMA_CHANNEL
     dmaINTSource        - One of the DMA interrupt sources specified by DMA_INT_TYPE
   Returns:
     None.
   Example:
     <code>
         DMA_CHANNEL spiDMAChannel = DMA_CHANNEL_2;
         PLIB_DMA_ChannelXINTSourceFlagClear ( DMA_ID_0,
                                             spiDMAChannel,
                                             DMA_INT_ADDRESS_ERROR );
     </code>
   Remarks:
         This function implements an operation of the ChannelXINTSourceFlag feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXINTSourceFlag function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXINTSourceFlagClear (
   DMA_MODULE_ID index ,
   DMA_CHANNEL dmaChannel ,
   DMA_INT_TYPE dmaINTSource ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXINTSourceEnable ( DMA_MODULE_ID index,
                                             DMA_CHANNEL dmaChannel,
                   DMA_INT_TYPE dmaINTSource )
   Summary:
     Enables the specified interrupt source for the specified channel.
   Description:
     This function enables the specified interrupt source for the specified channel.
   Precondition:
     None.
   Parameters:
     dmaChannel - One of the possible DMA channels listed by DMA_CHANNEL
     dmaINTSource - One of the DMA interrupt sources specified by DMA_INT_TYPE
   Returns:
     None.
   Example:
     <code>
         DMA_CHANNEL spiDMAChannel = DMA_CHANNEL_2;
         PLIB_DMA_ChannelXINTSourceEnable ( DMA_ID_0,
                                         spiDMAChannel,
                                         DMA_INT_ADDRESS_ERROR );
     </code>
   Remarks:
         This function implements an operation of the ChannelXINTSource feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXINTSource function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXINTSourceEnable (
   DMA_MODULE_ID index ,
   DMA_CHANNEL dmaChannel ,
   DMA_INT_TYPE dmaINTSource ) ;
 //******************************************************************************
 /* Function:
     void PLIB_DMA_ChannelXINTSourceDisable ( DMA_MODULE_ID index,
                                                 DMA_CHANNEL dmaChannel,
                                                 DMA_INT_TYPE dmaINTSource )
   Summary:
     Disables the specified interrupt source for the specified channel.
   Description:
     This function disables the specified interrupt source for the specified channel.
   Precondition:
     None.
   Parameters:
         dmaChannel - One of the possible DMA channels listed by DMA_CHANNEL
         dmaINTSource - One of the DMA interrupt sources specified by DMA_INT_TYPE
   Returns:
     None.
   Example:
     <code>
         DMA_CHANNEL spiDMAChannel = DMA_CHANNEL_2;
         PLIB_DMA_ChannelXINTSourceDisable ( DMA_ID_0,
                                         spiDMAChannel,
                                         DMA_INT_ADDRESS_ERROR );
     </code>
   Remarks:
         This function implements an operation of the ChannelXINTSource feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXINTSource function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXINTSourceDisable (
   DMA_MODULE_ID index ,
   DMA_CHANNEL dmaChannel ,
   DMA_INT_TYPE dmaINTSource ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_DMA_ChannelXINTSourceIsEnabled ( DMA_MODULE_ID index,
                                                 DMA_CHANNEL dmaChannel,
                                                 DMA_INT_TYPE dmaINTSource )
   Summary:
     Returns the enable status of the specified interrupt source for the specified channel.
   Description:
     This function returns the enable status of the specified interrupt source for the
         specified channel.
   Precondition:
     None.
   Parameters:
     dmaChannel   - One of the possible DMA channels listed by DMA_CHANNEL
         dmaINTSource - One of the DMA interrupt sources specified by DMA_INT_TYPE
   Returns:
     - true      - The interrupt is enabled
     - false     - The interrupt is not enabled
   Example:
     <code>
         DMA_CHANNEL spiDMAChannel = DMA_CHANNEL_2;
         bool dmaINTSourceEnableStatus;
         dmaINTSourceEnableStatus = PLIB_DMA_ChannelXINTSourceIsEnabled (
                                                         DMA_ID_0,
                                                         spiDMAChannel,
                                                         DMA_INT_ADDRESS_ERROR );
     </code>
   Remarks:
         This function implements an operation of the ChannelXINTSource feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXINTSource function in your application to automatically
         determine whether this feature is available.
 */

 bool
   PLIB_DMA_ChannelXINTSourceIsEnabled (
   DMA_MODULE_ID index ,
   DMA_CHANNEL dmaChannel ,
   DMA_INT_TYPE dmaINTSource ) ;
 //******************************************************************************
 /* Function:
         void PLIB_DMA_ChannelXPatternLengthSet( DMA_MODULE_ID index,
              DMA_CHANNEL dmaChannel,DMA_PATTERN_LENGTH patternLen )
   Summary:
     Sets the pattern match length.
   Description:
     This function sets the length of the pattern match ignore to 1 or 2 bytes.
   Precondition:
     None.
   Parameters:
         dmaChannel - One of the possible DMA channels listed by DMA_CHANNEL
         patternLen - Length of pattern match (either 1 or 2)
   Returns:
     None.
   Example:
     <code>
         DMA_CHANNEL dmaChannel = DMA_CHANNEL_2;
         DMA_PATTERN_LENGTH patternLen;
         patternLen = DMA_PATTERN_MATCH_LENGTH_1BYTE;
         PLIB_DMA_ChannelXPatternLengthSet(DMA_ID_0, dmaChannel, patternLen);
     </code>
   Remarks:
         This function implements an operation of the ChannelXPatternLength feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXPatternLength function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXPatternLengthSet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL dmaChannel ,
   DMA_PATTERN_LENGTH patternLen ) ;
 //******************************************************************************
 /* Function:
         DMA_PATTERN_LENGTH PLIB_DMA_ChannelXPatternLengthGet( DMA_MODULE_ID index,
                     DMA_CHANNEL dmaChannel);
   Summary:
     Returns the pattern match length.
   Description:
     This function returns the length of the byte matching the CHPIGN bits during a
     pattern match that may be ignored during the pattern match determination when
     the CHPIGNEN bit is set.
   Precondition:
     None.
   Parameters:
         dmaChannel - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
         - patternLen - Length of pattern match (either 1 or 2)
   Example:
     <code>
         DMA_CHANNEL dmaChannel = DMA_CHANNEL_2;
         DMA_PATTERN_LENGTH patternLen;
         patternLen = PLIB_DMA_ChannelXPatternLengthGet(DMA_ID_0, dmaChannel);
     </code>
   Remarks:
         This function implements an operation of the ChannelXPatternLength feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXPatternLength function in your application to automatically
         determine whether this feature is available.
 */

 DMA_PATTERN_LENGTH
   PLIB_DMA_ChannelXPatternLengthGet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL dmaChannel ) ;
 //******************************************************************************
 /* Function:
         void PLIB_DMA_ChannelXPatternIgnoreByteEnable ( DMA_MODULE_ID index,
                      DMA_CHANNEL channel );
   Summary:
     Enables the pattern match ignore byte.
   Description:
     This function enables the pattern match ignore byte.
   Precondition:
     None.
   Parameters:
     dmaChannel   - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     None.
   Example:
     <code>
         DMA_CHANNEL dmaChannel = DMA_CHANNEL_2;
         PLIB_DMA_ChannelXPatternIgnoreByteEnable(DMA_ID_0, dmaChannel);
     </code>
   Remarks:
         This function implements an operation of the ChannelXPatternIgnoreByte feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXPatternIgnoreByte function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXPatternIgnoreByteEnable (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
         bool PLIB_DMA_ChannelXPatternIgnoreByteIsEnabled ( DMA_MODULE_ID index,
                      DMA_CHANNEL channel );
   Summary:
     Returns the state of the pattern match ignore byte.
   Description:
     This function returns the state (enabled or disabled) of the pattern match
     ignore byte.
   Precondition:
     None.
   Parameters:
     dmaChannel   - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     - true - The pattern match ignore byte is enabled
     - false - The pattern match ignore byte is disabled
   Example:
     <code>
         bool patternIsEnabled;
         DMA_CHANNEL dmaChannel = DMA_CHANNEL_2;
         patternIsEnabled = PLIB_DMA_ChannelXPatternIgnoreByteIsEnabled(DMA_ID_0, dmaChannel);
     </code>
   Remarks:
         This function implements an operation of the ChannelXPatternIgnoreByte feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXPatternIgnoreByte function in your application to automatically
         determine whether this feature is available.
 */

 bool
   PLIB_DMA_ChannelXPatternIgnoreByteIsEnabled (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
         void PLIB_DMA_ChannelXPatternIgnoreByteDisable ( DMA_MODULE_ID index,
                      DMA_CHANNEL channel );
   Summary:
     Disables the pattern match ignore byte.
   Description:
     This function disables the pattern match ignore byte.
   Precondition:
     None.
   Parameters:
     dmaChannel   - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     None.
   Example:
     <code>
         DMA_CHANNEL dmaChannel = DMA_CHANNEL_2;
         PLIB_DMA_ChannelXPatternIgnoreByteDisable(DMA_ID_0, dmaChannel);
     </code>
   Remarks:
         This function implements an operation of the ChannelXPatternIgnoreByte feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXPatternIgnoreByte function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXPatternIgnoreByteDisable (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
         void PLIB_DMA_ChannelXPatternIgnoreSet (DMA_MODULE_ID index,
                   DMA_CHANNEL channel, uint8_t pattern );
   Summary:
     Sets the pattern match ignore value.
   Description:
     This function sets the value of the pattern match ignore.
   Precondition:
     None.
   Parameters:
     dmaChannel   - One of the possible DMA channels listed by DMA_CHANNEL
     pattern      - Pattern match ignore value
   Returns:
     None.
   Example:
     <code>
         uint8_t patternMatch = 0x8;
         DMA_CHANNEL dmaChannel = DMA_CHANNEL_2;
         PLIB_DMA_ChannelXPatternIgnoreSet ( DMA_ID_0, dmaChannel,patternMatch);
     </code>
   Remarks:
         This function implements an operation of the ChannelXPatternIgnore feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXPatternIgnore function in your application to automatically
         determine whether this feature is available.
 */

 void
   PLIB_DMA_ChannelXPatternIgnoreSet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ,
   uint8_t pattern ) ;
 //******************************************************************************
 /* Function:
         uint8_t PLIB_DMA_ChannelXPatternIgnoreGet( DMA_MODULE_ID index,
                    DMA_CHANNEL channel );
   Summary:
     Returns the pattern match ignore value.
   Description:
     This function returns the value of the pattern match ignore.
   Precondition:
     None.
   Parameters:
     dmaChannel  - One of the possible DMA channels listed by DMA_CHANNEL
   Returns:
     - uint8_t   - Pattern match ignore value
   Example:
     <code>
         uint8_t patternMatch;
         DMA_CHANNEL dmaChannel = DMA_CHANNEL_2;
         patternMatch = PLIB_DMA_ChannelXPatternIgnoreGet ( DMA_ID_0, dmaChannel);
     </code>
   Remarks:
         This function implements an operation of the ChannelXPatternIgnore feature.
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use the
         PLIB_DMA_ExistsChannelXPatternIgnore function in your application to automatically
         determine whether this feature is available.
 */

 uint8_t
   PLIB_DMA_ChannelXPatternIgnoreGet (
   DMA_MODULE_ID index ,
   DMA_CHANNEL channel ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: DMA Peripheral Library Exists API Routines
 // *****************************************************************************
 // *****************************************************************************
 /* The following functions indicate the existence of the features on the device.
 */
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsBusy( DMA_MODULE_ID index )
   Summary:
     Identifies whether the Busy feature exists on the DMA module.
   Description:
     This function identifies whether the Busy feature is available on the
         DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_BusyActiveSet
     - PLIB_DMA_BusyActiveReset
     - PLIB_DMA_IsBusy
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The Busy feature is supported on the device
     - false - The Busy feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsBusy (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsSuspend( DMA_MODULE_ID index )
   Summary:
     Identifies whether the Suspend feature exists on the DMA module.
   Description:
     This function identifies whether the Suspend feature is available on the
         DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_SuspendEnable
     - PLIB_DMA_SuspendDisable
     - PLIB_DMA_SuspendIsEnabled
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The Suspend feature is supported on the device
     - false - The Suspend feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsSuspend (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsStopInIdle( DMA_MODULE_ID index )
   Summary:
     Identifies whether the StopInIdle feature exists on the DMA module.
   Description:
     This function identifies whether the StopInIdle feature is available on the
         DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_StopInIdleEnable
     - PLIB_DMA_StopInIdleDisable
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The StopInIdle feature is supported on the device
     - false - The StopInIdle feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsStopInIdle (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsEnableControl( DMA_MODULE_ID index )
   Summary:
     Identifies whether the EnableControl feature exists on the DMA module.
   Description:
     This function identifies whether the EnableControl feature is available on
         the DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_Enable
     - PLIB_DMA_Disable
     - PLIB_DMA_IsEnabled
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The EnableControl feature is supported on the device
     - false - The EnableControl feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsEnableControl (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelBits( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelBits feature exists on the DMA module.
   Description:
     This function identifies whether the ChannelBits feature is available on the
         DMA module.
     When this function returns true, this function is supported on the device:
     - PLIB_DMA_ChannelBitsGet
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelBits feature is supported on the device
     - false - The ChannelBits feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelBits (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsLastBusAccess( DMA_MODULE_ID index )
   Summary:
     Identifies whether the LastBusAccess feature exists on the DMA module.
   Description:
     This function identifies whether the LastBusAccess feature is available on the
         DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_LastBusAccessIsRead
     - PLIB_DMA_LastBusAccessIsWrite
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The LastBusAccess feature is supported on the device
     - false - The LastBusAccess feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsLastBusAccess (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsRecentAddress( DMA_MODULE_ID index )
   Summary:
     Identifies whether the RecentAddress feature exists on the DMA module.
   Description:
     This function identifies whether the RecentAddress feature is available on
         the DMA module.
     When this function returns true, this function is supported on the device:
     - PLIB_DMA_RecentAddressAccessed
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The RecentAddress feature is supported on the device
     - false - The RecentAddress feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsRecentAddress (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsCRCChannel( DMA_MODULE_ID index )
   Summary:
     Identifies whether the CRCChannel feature exists on the DMA module.
   Description:
     This function identifies whether the CRCChannel feature is available on the
         DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_CRCChannelSelect
     - PLIB_DMA_CRCChannelGet
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The CRCChannel feature is supported on the device
     - false - The CRCChannel feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsCRCChannel (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsCRCType( DMA_MODULE_ID index )
   Summary:
     Identifies whether the CRCType feature exists on the DMA module.
   Description:
     This function identifies whether the CRCType feature is available on the
         DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_CRCTypeGet
     - PLIB_DMA_CRCTypeSet
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The CRCType feature is supported on the device
     - false - The CRCType feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsCRCType (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsCRCAppendMode( DMA_MODULE_ID index )
   Summary:
     Identifies whether the CRCAppendMode feature exists on the DMA module.
   Description:
     This function identifies whether the CRCAppendMode feature is available on
         the DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_CRCAppendModeEnable
     - PLIB_DMA_CRCAppendModeDisable
     - PLIB_DMA_CRCAppendModeIsEnabled
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The CRCAppendMode feature is supported on the device
     - false - The CRCAppendMode feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsCRCAppendMode (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsCRC( DMA_MODULE_ID index )
   Summary:
     Identifies whether the CRC feature exists on the DMA module.
   Description:
     This function identifies whether the CRC feature is available on the DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_CRCEnable
     - PLIB_DMA_CRCDisable
     - PLIB_DMA_CRCIsEnabled
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The CRC feature is supported on the device
     - false - The CRC feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsCRC (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsCRCPolynomialLength( DMA_MODULE_ID index )
   Summary:
     Identifies whether the CRCPolynomialLength feature exists on the DMA module.
   Description:
     This function identifies whether the CRCPolynomialLength feature is available
         on the DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_CRCPolynomialLengthSet
     - PLIB_DMA_CRCPolynomialLengthGet
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The CRCPolynomialLength feature is supported on the device
     - false - The CRCPolynomialLength feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsCRCPolynomialLength (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsCRCBitOrder( DMA_MODULE_ID index )
   Summary:
     Identifies whether the CRCBitOrder feature exists on the DMA module.
   Description:
     This function identifies whether the CRCBitOrder feature is available on the
         DMA module.
     When this function returns true, this function is supported on the device:
     - PLIB_DMA_CRCBitOrderSelect
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The CRCBitOrder feature is supported on the device
     - false - The CRCBitOrder feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsCRCBitOrder (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsCRCWriteByteOrder( DMA_MODULE_ID index )
   Summary:
     Identifies whether the CRCWriteByteOrder feature exists on the DMA module.
   Description:
     This function identifies whether the CRCWriteByteOrder feature is available
         on the DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_CRCWriteByteOrderAlter
     - PLIB_DMA_CRCWriteByteOrderMaintain
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The CRCWriteByteOrder feature is supported on the device
     - false - The CRCWriteByteOrder feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsCRCWriteByteOrder (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsCRCByteOrder( DMA_MODULE_ID index )
   Summary:
     Identifies whether the CRCByteOrder feature exists on the DMA module.
   Description:
     This function identifies whether the CRCByteOrder feature is available on
         the DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_CRCByteOrderSelect
     - PLIB_DMA_CRCByteOrderGet
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The CRCByteOrder feature is supported on the device
     - false - The CRCByteOrder feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsCRCByteOrder (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsCRCData( DMA_MODULE_ID index )
   Summary:
     Identifies whether the CRCData feature exists on the DMA module.
   Description:
     This function identifies whether the CRCData feature is available on the
         DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_CRCDataRead
     - PLIB_DMA_CRCDataWrite
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The CRCData feature is supported on the device
     - false - The CRCData feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsCRCData (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsCRCXOREnable( DMA_MODULE_ID index )
   Summary:
     Identifies whether the CRCXOREnable feature exists on the DMA module.
   Description:
     This function identifies whether the CRCXOREnable feature is available on the
         DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_CRCXOREnableSet
     - PLIB_DMA_CRCXOREnableGet
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The CRCXOREnable feature is supported on the device
     - false - The CRCXOREnable feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsCRCXOREnable (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelXPriority( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelXPriority feature exists on the DMA module.
   Description:
     This function identifies whether the ChannelXPriority feature is available on
         the DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_ChannelXPrioritySelect
     - PLIB_DMA_ChannelXPriorityGet
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelXPriority feature is supported on the device
     - false - The ChannelXPriority feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelXPriority (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelXEvent( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelXEvent feature exists on the DMA module.
   Description:
     This function identifies whether the ChannelXEvent feature is available on
         the DMA module.
     When this function returns true, this function is supported on the device:
     - PLIB_DMA_ChannelXEventIsDetected
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelXEvent feature is supported on the device
     - false - The ChannelXEvent feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelXEvent (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelXAuto( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelXAuto feature exists on the DMA module.
   Description:
     This function identifies whether the ChannelXAuto feature is available on
         the DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_ChannelXAutoEnable
     - PLIB_DMA_ChannelXAutoDisable
     - PLIB_DMA_ChannelXAutoIsEnabled
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelXAuto feature is supported on the device
     - false - The ChannelXAuto feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelXAuto (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelXChainEnbl( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelXChainEnbl feature exists on the DMA module.
   Description:
     This function identifies whether the ChannelXChainEnbl feature is available
         on the DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_ChannelXChainEnable
     - PLIB_DMA_ChannelXChainDisable
     - PLIB_DMA_ChannelXChainIsEnabled
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelXChainEnbl feature is supported on the device
     - false - The ChannelXChainEnbl feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelXChainEnbl (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelXDisabled( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelXDisabled feature exists on the DMA module.
   Description:
     This function identifies whether the ChannelXDisabled feature is available
         on the DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_ChannelXDisabledEnablesEvents
     - PLIB_DMA_ChannelXDisabledDisablesEvents
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelXDisabled feature is supported on the device
     - false - The ChannelXDisabled feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelXDisabled (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelX( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelX feature exists on the DMA module.
   Description:
     This function identifies whether the ChannelX feature is available on the
         DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_ChannelXEnable
     - PLIB_DMA_ChannelXIsEnabled
     - PLIB_DMA_ChannelXDisable
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelX feature is supported on the device
     - false - The ChannelX feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelX (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelXChain( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelXChain feature exists on the DMA module.
   Description:
     This function identifies whether the ChannelXChain feature is available on the
         DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_ChannelXChainToLower
     - PLIB_DMA_ChannelXChainToHigher
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelXChain feature is supported on the device
     - false - The ChannelXChain feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelXChain (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelXPatternLength( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelXPatternLength feature exists on the DMA module.
   Description:
     This function identifies whether the ChannelXPatternLength feature is available
         on the DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_ChannelXPatternLengthSet
     - PLIB_DMA_ChannelXPatternLengthGet
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelXPatternLength feature is supported on the device
     - false - The ChannelXPatternLength feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelXPatternLength (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelXPatternIgnoreByte( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelXPatternIgnoreByte feature exists on the DMA
         module.
   Description:
     This function identifies whether the ChannelXPatternIgnoreByte feature is
         available on the DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_ChannelXPatternIgnoreByteEnable
     - PLIB_DMA_ChannelXPatternIgnoreByteIsEnabled
     - PLIB_DMA_ChannelXPatternIgnoreByteDisable
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelXPatternIgnoreByte feature is supported on the device
     - false - The ChannelXPatternIgnoreByte feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelXPatternIgnoreByte (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelXBusy( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelXBusy feature exists on the DMA module.
   Description:
     This function identifies whether the ChannelXBusy feature is available on the
         DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_ChannelXBusyActiveSet
     - PLIB_DMA_ChannelXBusyInActiveSet
     - PLIB_DMA_ChannelXBusyIsBusy
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelXBusy feature is supported on the device
     - false - The ChannelXBusy feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelXBusy (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelXPatternIgnore( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelXPatternIgnore feature exists on the DMA module.
   Description:
     This function identifies whether the ChannelXPatternIgnore feature is available
         on the DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_ChannelXPatternIgnoreSet
     - PLIB_DMA_ChannelXPatternIgnoreGet
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelXPatternIgnore feature is supported on the device
     - false - The ChannelXPatternIgnore feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelXPatternIgnore (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelXTrigger( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelXTrigger feature exists on the DMA module.
   Description:
     This function identifies whether the ChannelXTrigger feature is available on
         the DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_ChannelXTriggerEnable
     - PLIB_DMA_ChannelXTriggerIsEnabled
     - PLIB_DMA_ChannelXTriggerDisable
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelXTrigger feature is supported on the device
     - false - The ChannelXTrigger feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelXTrigger (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsAbortTransfer( DMA_MODULE_ID index )
   Summary:
     Identifies whether the AbortTransfer feature exists on the DMA module.
   Description:
     This function identifies whether the AbortTransfer feature is available on
         the DMA module.
     When this function returns true, this function is supported on the device:
     - PLIB_DMA_AbortTransferSet
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The AbortTransfer feature is supported on the device
     - false - The AbortTransfer feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsAbortTransfer (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsStartTransfer( DMA_MODULE_ID index )
   Summary:
     Identifies whether the StartTransfer feature exists on the DMA module.
   Description:
     This function identifies whether the StartTransfer feature is available on
         the DMA module.
     When this function returns true, this function is supported on the device:
     - PLIB_DMA_StartTransferSet
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The StartTransfer feature is supported on the device
     - false - The StartTransfer feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsStartTransfer (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelXStartIRQ( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelXStartIRQ feature exists on the DMA module.
   Description:
     This function identifies whether the ChannelXStartIRQ feature is available
         on the DMA module.
     When this function returns true, this function is supported on the device:
     - PLIB_DMA_ChannelXStartIRQSet
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelXStartIRQ feature is supported on the device
     - false - The ChannelXStartIRQ feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelXStartIRQ (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelXAbortIRQ( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelXAbortIRQ feature exists on the DMA module.
   Description:
     This function identifies whether the ChannelXAbortIRQ feature is available
         on the DMA module.
     When this function returns true, this function is supported on the device:
     - PLIB_DMA_ChannelXAbortIRQSet
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelXAbortIRQ feature is supported on the device
     - false - The ChannelXAbortIRQ feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelXAbortIRQ (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelXINTSourceFlag( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelXINTSourceFlag feature exists on the DMA module.
   Description:
     This function identifies whether the ChannelXINTSourceFlag feature is available
         on the DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_ChannelXINTSourceFlagGet
     - PLIB_DMA_ChannelXINTSourceFlagSet
     - PLIB_DMA_ChannelXINTSourceFlagClear
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelXINTSourceFlag feature is supported on the device
     - false - The ChannelXINTSourceFlag feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelXINTSourceFlag (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelXINTSource( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelXINTSource feature exists on the DMA module.
   Description:
     This function identifies whether the ChannelXINTSource feature is available
         on the DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_ChannelXINTSourceEnable
     - PLIB_DMA_ChannelXINTSourceDisable
     - PLIB_DMA_ChannelXINTSourceIsEnabled
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelXINTSource feature is supported on the device
     - false - The ChannelXINTSource feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelXINTSource (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelXSourceStartAddress( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelXSourceStartAddress feature exists on the DMA module.
   Description:
     This function identifies whether the ChannelXSourceStartAddress feature is available
         on the DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_ChannelXSourceStartAddressGet
     - PLIB_DMA_ChannelXSourceStartAddressSet
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelXSourceStartAddress feature is supported on the device
     - false - The ChannelXSourceStartAddress feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelXSourceStartAddress (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelXDestinationStartAddress( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelXDestinationStartAddress feature exists on
         the DMA module.
   Description:
     This function identifies whether the ChannelXDestinationStartAddress feature
         is available on the DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_ChannelXDestinationStartAddressGet
     - PLIB_DMA_ChannelXDestinationStartAddressSet
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelXDestinationStartAddress feature is supported on the device
     - false - The ChannelXDestinationStartAddress feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelXDestinationStartAddress (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelXSourceSize( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelXSourceSize feature exists on the DMA module.
   Description:
     This function identifies whether the ChannelXSourceSize feature is available
         on the DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_ChannelXSourceSizeGet
     - PLIB_DMA_ChannelXSourceSizeSet
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelXSourceSize feature is supported on the device
     - false - The ChannelXSourceSize feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelXSourceSize (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelXDestinationSize( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelXDestinationSize feature exists on the DMA module.
   Description:
     This function identifies whether the ChannelXDestinationSize feature is available
         on the DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_ChannelXDestinationSizeGet
     - PLIB_DMA_ChannelXDestinationSizeSet
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelXDestinationSize feature is supported on the device
     - false - The ChannelXDestinationSize feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelXDestinationSize (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelXSourcePointer( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelXSourcePointer feature exists on the DMA module.
   Description:
     This function identifies whether the ChannelXSourcePointer feature is available
         on the DMA module.
     When this function returns true, this function is supported on the device:
     - PLIB_DMA_ChannelXSourcePointerGet
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelXSourcePointer feature is supported on the device
     - false - The ChannelXSourcePointer feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelXSourcePointer (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelXDestinationPointer( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelXDestinationPointer feature exists on the DMA module.
   Description:
     This function identifies whether the ChannelXDestinationPointer feature is available
         on the DMA module.
     When this function returns true, this function is supported on the device:
     - PLIB_DMA_ChannelXDestinationPointerGet
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelXDestinationPointer feature is supported on the device
     - false - The ChannelXDestinationPointer feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelXDestinationPointer (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelXCellSize( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelXCellSize feature exists on the DMA module.
   Description:
     This function identifies whether the ChannelXCellSize feature is available on
         the DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_ChannelXCellSizeGet
     - PLIB_DMA_ChannelXCellSizeSet
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelXCellSize feature is supported on the device
     - false - The ChannelXCellSize feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelXCellSize (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelXCellProgressPointer( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelXCellProgressPointer feature exists on the
         DMA module.
   Description:
     This function identifies whether the ChannelXCellProgressPointer feature is
         available on the DMA module.
     When this function returns true, this function is supported on the device:
     - PLIB_DMA_ChannelXCellProgressPointerGet
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelXCellProgressPointer feature is supported on the device
     - false - The ChannelXCellProgressPointer feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelXCellProgressPointer (
   DMA_MODULE_ID index ) ;
 //******************************************************************************
 /* Function : PLIB_DMA_ExistsChannelXPatternData( DMA_MODULE_ID index )
   Summary:
     Identifies whether the ChannelXPatternData feature exists on the DMA module
   Description:
     This function identifies whether the ChannelXPatternData feature is available
         on the DMA module.
     When this function returns true, these functions are supported on the device:
     - PLIB_DMA_ChannelXPatternDataGet
     - PLIB_DMA_ChannelXPatternDataSet
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelXPatternData feature is supported on the device
     - false - The ChannelXPatternData feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_DMA_ExistsChannelXPatternData (
   DMA_MODULE_ID index ) ;
 //DOM-IGNORE-BEGIN
 //DOM-IGNORE-END
        // #ifndef _PLIB_DMA_H
 /*******************************************************************************
  End of File
 */

 #endif /*00 C:\microchip\harmony\v2_06\framework\peripheral\dma\plib_dma.h*/
 /*   CLOSE_FILE Include File */

 // *****************************************************************************
 // *****************************************************************************
 // Section: Data Types
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* DMA System Service Channel None
  Summary:
  DMA channel none
  Description:
  This constant identifies the specification of no choice from client
  for allocating a particular DMA channel.
  Remarks:
  This constant should be used in place of hard-coded numeric literals.
 */
 //DOM-IGNORE-BEGIN
 #define DMA_CHANNEL_NONE ( ( DMA_CHANNEL ) - 1 )
 //DOM-IGNORE-END
 // *****************************************************************************
 /* DMA System Service Channel Any
  Summary:
  Identifies the client specification to allocate any available DMA channel.
  Description:
  This constant identifies the specification by the client
  to allocate any available DMA channel.
  Remarks:
  This constant should be used in place of hard-coded numeric literals.
 */
 //DOM-IGNORE-BEGIN
 #define DMA_CHANNEL_ANY ( ( DMA_CHANNEL ) - 2 )
 //DOM-IGNORE-END
 // *****************************************************************************
 /* DMA System Service Channel Count
  Summary:
  Identifies the maximum number of DMA channel handles to be defined.
  Description:
  This constant identifies the maximum number of DMA channel handles
  that should be defined.
  Remarks:
  This value is derived from device-specific header files defined as
  part of the peripheral libraries.
 */
 #define SYS_DMA_CHANNEL_COUNT DMA_NUMBER_OF_CHANNELS
 // *****************************************************************************
 /* DMA System Service Channel Handle
  Summary:
  Assigns the handle for requested channel.
  Description:
  A channel handle value is returned by a call to the SYS_DMA_ChannelAllocate
  function. This handle is associated with the channel number that is used for
  data transfer and it allows the application to track the data transfer.
  The channel handle once assigned to a client expires when the
  client calls SYS_DMA_ChannelRelease.
  exits.
  Remarks:
  None.
 */

 typedef
 uintptr_t
   SYS_DMA_CHANNEL_HANDLE ;
 // *****************************************************************************
 /* DMA System Service Invalid Channel Handle
  Summary:
  Defines an invalid channel handle.
  Description:
  This is the definition of an invalid channel handle. An invalid buffer handle
  is returned by SYS_DMA_ChannelAllocate function if the channel number
  request was not successful.
  Remarks:
  None.
 */
 #define SYS_DMA_CHANNEL_HANDLE_INVALID ( ( SYS_DMA_CHANNEL_HANDLE ) ( - 1 ) )
 // *****************************************************************************
 /* DMA stop in idle mode
  Summary:
  Enable/Disable DMA operations in Idle mode.
  Description:
  This data type allows enabling/disabling of DMA operations in idle mode.
  Remarks:
  The field 'sidl' (in init data structure 'SYS_DMA_INIT') is enable/disable
  while initializing the DMA module by calling SYS_DMA_Initialize.
  This feature may not be available on all devices. Refer to the specific device
         data sheet to determine availability.
 */

 typedef
   enum
   {
     /* When the CPU enters idle mode, the DMA module continue operations */
     SYS_DMA_SIDL_DISABLE ,
     /* When the CPU enters idle mode, the DMA module will discontinue operations */
     SYS_DMA_SIDL_ENABLE
   } SYS_DMA_SIDL ;
 // *****************************************************************************
 /* DMA Channel chaining priority
  Summary:
  Identifies the priority of chaining channel.
  Description:
  This data type identifies the priority of chaining channel.
  Channel chaining priority identifies the channel that will be enabled
  on completion of block data transfer on the master channel.
  Remarks:
  None.
 */

 typedef
   enum
   {
     /* Chain to channel higher in natural priority */
     SYS_DMA_CHANNEL_CHAIN_PRIO_HIGH ,
     /* Chain to channel lower in natural priority */
     SYS_DMA_CHANNEL_CHAIN_PRIO_LOW
   } SYS_DMA_CHANNEL_CHAIN_PRIO ;
 // *****************************************************************************
 /* DMA Channel ignore pattern match
  Summary:
  Enables/Disables the feature to ignore a byte between a 2-byte match abort
  pattern.
  Description:
  This data type allows enabling/disabling the feature to ignore a byte
  between a 2-byte match abort pattern.
  Remarks:
  This feature may not be available on all devices. Refer to the specific device
         data sheet to determine availability.
 */

 typedef
   enum
   {
     /* Disabling the feature to ignore a byte between a 2-byte match abort pattern. */
     SYS_DMA_CHANNEL_IGNORE_MATCH_DISABLE ,
     /* Enable the feature to ignore a byte between a 2-byte match abort pattern. */
     SYS_DMA_CHANNEL_IGNORE_MATCH_ENABLE
   } SYS_DMA_CHANNEL_IGNORE_MATCH ;
 // *****************************************************************************
 /* DMA channel CRC mode
  Summary:
  Identifies the operation mode of the CRC module.
  Description:
  This data type identifies CRC operating mode. The CRC computation can be
  in background mode or append mode.
  Remarks:
  None.
 */

 typedef
   enum
   {
     /* DMA reads the data from the source, passes it through the CRC module and
        writes it to the destination. the calculated CRC is left in the DCRCDATA
        register at the end of the block transfer. */
     SYS_DMA_CHANNEL_CRC_MODE_BACKGROUND ,
     /* DMA only feeds source data to the CRC module. it does not write source data
        to the destination address. When a block transfer complete or pattern abort
        event occur, The DMA writes the CRC value to the destination address */
     SYS_DMA_CHANNEL_CRC_MODE_APPEND
   } SYS_DMA_CHANNEL_CRC_MODE ;
 // *****************************************************************************
 /* DMA channel CRC write order
  Summary:
  Identifies altering/maintaining write order post CRC computation.
  Description:
  This data type identifies write byte order selection post CRC
  computation.
  Remarks:
  None.
 */

 typedef
   enum
   {
     /* Source data is written to the destination unchanged regardless
        of the selected pre-CRC byte order. */
     SYS_DMA_CRC_WRITE_ORDER_MAINTAIN ,
     /* Source data is written to the destination reordered according
        to the selected pre-CRC byte order. */
     SYS_DMA_CRC_WRITE_ORDER_CHANGE
   } SYS_DMA_CRC_WRITE_ORDER ;
 // *****************************************************************************
 /* DMA channel operation modes
  Summary:
  Identifies the available DMA operating modes.
  Description:
  This data type Identifies the available DMA operating modes.
  The supported DMA modes are not mutually exclusive, but can be simultaneously
  operational.
  Remarks:
  These supported DMA modes can be logically OR'd together. They are passed
  into the SYS_DMA_ChannelSetup function through the modeEnable parameter.
 */

 typedef
   enum
   {
     /* The normal DMA operation mode. The DMA channel will transfer data from
        a source to a destination without CPU intervention */
     SYS_DMA_CHANNEL_OP_MODE_BASIC /*DOM-IGNORE-BEGIN*/
     = ( 1 << 0 )                                                /*DOM-IGNORE-END*/
       ,
     /* Pattern Match abort mode allows the user to end a transfer if data
        written during a transaction matches a specific pattern, as defined by
        the DCHxDAT register */
       SYS_DMA_CHANNEL_OP_MODE_MATCH_ABORT/*DOM-IGNORE-BEGIN*/
     = ( 1 << 1 )                                                      /*DOM-IGNORE-END*/
       ,
     /* Channel chaining operating mode enhances the normal DMA channel
        operations. A channel(slave) can be chained to an adjacent channel(master).
        The slave channel will be enabled when a block transfer of the master
        channel completes. */
     /* only one of the below two chaining priorities must be provided.
        Chaining priority High. */
       SYS_DMA_CHANNEL_OP_MODE_CHAIN_HIGH/*DOM-IGNORE-BEGIN*/
     = ( 1 << 2 )                                                     /*DOM-IGNORE-END*/
       ,
       /* Chaining priority Low */
       SYS_DMA_CHANNEL_OP_MODE_CHAIN_LOW/*DOM-IGNORE-BEGIN*/
     = ( 1 << 3 )                                                    /*DOM-IGNORE-END*/
       ,
     /* Auto enable operating mode allows a channel to be kept active, even if a
        block transfer completes or pattern match occurs. This prevents the user
        from having to re-enable the channel each time a block transfer completes. */
       SYS_DMA_CHANNEL_OP_MODE_AUTO/*DOM-IGNORE-BEGIN*/
     = ( 1 << 4 )                                               /*DOM-IGNORE-END*/
       ,
       /* CRC operating mode allows computation of 16, 32-bit CRC. */
       SYS_DMA_CHANNEL_OP_MODE_CRC/*DOM-IGNORE-BEGIN*/
     = ( 1 << 5 )                                              /*DOM-IGNORE-END*/
   } SYS_DMA_CHANNEL_OP_MODE ;
 // *****************************************************************************
 /* DMA channel CRC mode
  Summary:
  Defines the attributes for CRC operation mode.
  Description:
  This data type defines the attributes for CRC operation mode.
  Remarks:
  This feature may not be available on all devices. Refer to the specific device
         data sheet to determine availability.
 */

 typedef
   struct
   {
     /* CRC type (PLIB-level).
        Type Selection identifies whether the CRC module will calculate an IP
        header checksum or an LFSR CRC */
     DMA_CRC_TYPE type ;
     /* CRC mode, Background or Append */
     SYS_DMA_CHANNEL_CRC_MODE mode ;
     /* Polynomial length, This value is redundant when the selected CRC type is
        IP header checksum. When the CRC type is LFSR, Identifies the length of
        the polynomial. */
     uint8_t polyLength ;
     /* Bit order (PLIB-level).
        Identifies whether the CRC is computed LSb or MSb first */
     DMA_CRC_BIT_ORDER bitOrder ;
     /* Byte order (PLIB-level).
        Identifies the byte selection order input pre-CRC Generator. */
     DMA_CRC_BYTE_ORDER byteOrder ;
     /* Post CRC Write order */
     SYS_DMA_CRC_WRITE_ORDER writeOrder ;
     /* CRC data feed: While enabling the CRC mode, this field gives
        the seed for the CRC computation. On block transfer complete or
        pattern match abort the field have the computed CRC. */
     uint32_t data ;
     /* XOR bit mask, This value is redundant when the selected CRC type is
        IP header checksum. When the CRC type is LFSR, Identifies the XOR
        bit mask input to the shift register during CRC computation. */
     uint32_t xorBitMask ;
   } SYS_DMA_CHANNEL_OPERATION_MODE_CRC ;
 // *****************************************************************************
 /* DMA System service Events
  Summary:
  Enumeration of possible DMA System service events.
  Description:
  This data type provides an enumeration of all possible DMA System service events.
  Remarks:
  None.
 */

 typedef
   enum
   {
     /* Data was transferred successfully. */
     SYS_DMA_TRANSFER_EVENT_COMPLETE ,
     /* Error while processing the request */
     SYS_DMA_TRANSFER_EVENT_ERROR ,
     /* Data transfer was aborted. */
     SYS_DMA_TRANSFER_EVENT_ABORT ,
     /* No events yet. */
     SYS_DMA_TRANSFER_EVENT_NONE
   } SYS_DMA_TRANSFER_EVENT ;
 // *****************************************************************************
 /* DMA System service Error
  Summary:
  Indicates the error information for the DMA System service.
  Description:
  This enumeration indicates the error information for the DMA System service.
  Remarks:
  None.
 */

 typedef
   enum
   {
     /* Data was transferred successfully. */
     SYS_DMA_ERROR_NONE /*DOM-IGNORE-BEGIN*/
     = 1 << 0 ,
                                                       /* DOM-IGNORE-END*/
     /* DMA address error. */
     SYS_DMA_ERROR_ADDRESS_ERROR /*DOM-IGNORE-BEGIN*/
     = 1 << 1                                                  /* DOM-IGNORE-END*/
   } SYS_DMA_ERROR ;
 // *****************************************************************************
 /* DMA Initialization data
  Summary:
  Defines the data required to initialize the DMA subsystem.
  Description:
  This data type defines the data required to initialize the DMA subsystem.
  Remarks:
  This feature may not be available on all devices. Refer to the specific device
         data sheet to determine availability.
 */

 typedef
   struct
   {
     /* Enable/Disable stop in idle mode feature */
     SYS_DMA_SIDL sidl ;
   } SYS_DMA_INIT ;
 // *****************************************************************************
 /* Data width options */

 typedef
   enum
   {
     /* Data width configuration feature is not available */
     SYS_DMA_DATA_WIDTH_NONE
   } SYS_DMA_DATA_WIDTH ;
 // *****************************************************************************
 /* DMA descriptor control
  Summary:
  Defines the descriptor control for linked list operation.
  Description:
  This data type defines the descriptor control for linked list operation.
  Remarks:
  This feature may not be available on all devices. Refer to the specific device
         data sheet to determine availability.
 */

 typedef
   union
   {
     /* Feature is not supported */
     ;
   } SYS_DMA_DESCRIPTOR_CONTROL ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: Initialization and Task Functions
 // *****************************************************************************
 // *****************************************************************************
 //******************************************************************************
 /* Function:
  void SYS_DMA_Tasks(SYS_MODULE_OBJ object, DMA_CHANNEL activeChannel)
  Summary:
  Maintains the system service's state machine.

  Description:
  This function is used to maintain the DMA system service's internal state
  machine. This function services events on a specific DMA channel.
  Precondition:
  DMA should have been initialized by calling SYS_DMA_Initialize.
  Parameters:
  object - Object handle for the DMA module (returned from
  SYS_DMA_Initialize)
  activeChannel - DMA channel number to be serviced.
  Returns:
  None.
  Example:
  <code>
  // 'object' Returned from SYS_DMA_Initialize
         void __ISR(_DMA3_VECTOR,ipl5)_InterruptHandler_BT_USART_RX_DMA_CHANNEL(void)
         {
          SYS_DMA_Tasks(object, DMA_CHANNEL_3);
         }
  </code>
  Remarks:
  This function is normally not called directly by an application. It is
  called by the system's task/interrupt routines.
  */

 void
   SYS_DMA_Tasks (
   SYS_MODULE_OBJ object ,
   DMA_CHANNEL activeChannel ) ;
 //******************************************************************************
 /* For backward compatibility */
 #define SYS_DMA_TasksISR( object , activeChannel ) SYS_DMA_Tasks ( object , activeChannel )
        // #ifndef _SYS_DMA_DEFINITIONS_H
 /*******************************************************************************
  End of File
 */
 #endif /*00 C:\microchip\harmony\v2_06\framework\system\dma\sys_dma_definitions.h*/
 /*   CLOSE_FILE Include File */

 // DOM-IGNORE-BEGIN
 // DOM-IGNORE-END
 // *****************************************************************************
 // *****************************************************************************
 // Section: DMA System Service Interface Routines
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* DMA System service Transfer Event Handler Function
    Summary:
     Pointer to a DMA System service Transfer Event handler function.
    Description:
     This data type defines a DMA System service Transfer Event Handler Function.
     A DMA system service client must register an transfer event handler function of
     this type to receive transfer related events from the system service.
     If the event is SYS_DMA_TRANSFER_EVENT_COMPLETE, this means that the data
     was transferred successfully. The channelHandle parameter contains the channel
     handle of the channel on which the transfer was processed.
     If the event is SYS_DMA_TRANSFER_EVENT_ERROR, this means that the data was
     not transferred successfully. TThe channelHandle parameter contains the channel
     handle of the channel on which the transfer had failed.
     The contextHandle parameter contains the context handle that was provided by
     the client at the time of registering the event handler. This context handle
     can be anything that the client consider helpful or necessary to identify
     the client context object associated with the channel of the system
     service that generated the event.
     The event handler function executes in an interrupt context when DMA is setup
     to start operation by an interrupt trigger source. It is recommended of the
     application to not perform process intensive operations with in this
     function.
    Remarks:
     None.
 */

 typedef
 void ( * SYS_DMA_CHANNEL_TRANSFER_EVENT_HANDLER ) ( SYS_DMA_TRANSFER_EVENT event ,
 SYS_DMA_CHANNEL_HANDLE handle ,
 uintptr_t contextHandle ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: Initialization and Task Functions
 // *****************************************************************************
 // *****************************************************************************
 //******************************************************************************
 /* Function:
     SYS_MODULE_OBJ SYS_DMA_Initialize(const SYS_MODULE_INIT * const init)
   Summary:
     Initializes and Enables the DMA Controller.
   Description:
     This function Enables the DMA module. Enable/Disable stop in idle mode
     feature based on the passed parameter value.
     This function initializes the DMA module making it ready for clients to
     open and use it. The initialization data is specified by the init parameter.
   Precondition:
     None.
   Parameters:
     init - Pointer to the data structure containing any data
                       necessary to initialize the hardware. This pointer may
                       be null if no data is required and default
                       initialization is to be used.
   Returns:
     If successful, returns a valid handle to the DMA module object.
     Otherwise, it returns SYS_MODULE_OBJ_INVALID.
   Example:
   <code>
     SYS_MODULE_OBJ objectHandle;
     SYS_DMA_INIT initParam;
     initParam.sidl = SYS_DMA_SIDL_ENABLE;
     objectHandle = SYS_DMA_Initialize(DRV_I2S_INDEX_1,
                                       (SYS_MODULE_INIT*)initParam);
     if (SYS_MODULE_OBJ_INVALID == objectHandle)
     {
         // Handle error
     }
   </code>
   Remarks:
     This function must be called before any other DMA systems service routines
     are called.
     Not all features are available on all micro-controllers.
 */

 SYS_MODULE_OBJ
   SYS_DMA_Initialize (
   const SYS_MODULE_INIT * const init ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: Channel Setup and management functions
 // *****************************************************************************
 // *****************************************************************************
 //******************************************************************************
 /* Function:
     SYS_DMA_CHANNEL_HANDLE SYS_DMA_ChannelAllocate (DMA_CHANNEL channel)
   Summary:
     Allocates the specified DMA channel and returns a handle to it.
   Description:
     This function opens the specified DMA channel and provides a
     handle that must be provided to all other client-level operations to
     identify the caller and the DMA channel.
   Precondition:
     Function SYS_DMA_Initialize must have been called before calling this
     function.
   Parameters:
     channel - Channel number requested for allocation.
                   When channel number specified is DMA_CHANNEL_ANY
                   a random channel is allocated for DMA transfers.
   Returns:
      The channel handle for the requested channel number.
      If an error occurs, the return value is SYS_DMA_CHANNEL_HANDLE_INVALID.
      Error can occur.
      - if the requested channel number is invalid.
      - if the requested channel number is not free.
   Example:
   <code>
     DMA_CHANNEL channel;
     SYS_DMA_CHANNEL_HANDLE handle
     channel = DMA_CHANNEL_2;
     handle = SYS_DMA_ChannelAllocate(channel);
     if (SYS_DMA_CHANNEL_HANDLE_INVALID == handle)
     {
         // Failed to allocate the channel
     }
     else
     {
         // Proceed with setting up the channel and adding the transfer
     }
   </code>
   Remarks:
     The handle returned is valid until the SYS_DMA_ChannelRelease routine is called.
     This function must be called before any other DMA channel Setup and management
     routines are called
 */

 SYS_DMA_CHANNEL_HANDLE
   SYS_DMA_ChannelAllocate (
   DMA_CHANNEL channel ) ;
 //******************************************************************************
 /* Function:
     void SYS_DMA_ChannelRelease(SYS_DMA_CHANNEL_HANDLE handle)
   Summary:
     Deallocates and frees the channel specified by the handle.
   Description:
     This function deallocates an allocated-channel of the DMA module,
     invalidating the handle.
   Precondition:
     DMA should have been initialized by calling SYS_DMA_Initialize.
     DMA channel should have been allocated by calling SYS_DMA_ChannelAllocate
   Parameters:
     handle - A valid allocated-channel handle, returned from the service's
                       Allocate routine
   Returns:
     None.
   Example:
   <code>
     DMA_CHANNEL channel;
     SYS_DMA_CHANNEL_HANDLE handle;
     channel = DMA_CHANNEL_2;
     handle = SYS_DMA_ChannelAllocate(channel);
     SYS_DMA_ChannelRelease(handle);
   </code>
   Remarks:
     After calling this routine, the handle passed in "handle" must not be used
     with any of the remaining service's routines. A new handle must be obtained by
     calling SYS_DMA_ChannelAllocate before the caller may use the service again
 */

 void
   SYS_DMA_ChannelRelease (
   SYS_DMA_CHANNEL_HANDLE handle ) ;
 //******************************************************************************
 /* Function:
     void SYS_DMA_ChannelSetup
     (
         SYS_DMA_CHANNEL_HANDLE handle,
         SYS_DMA_CHANNEL_OP_MODE modeEnable
         DMA_TRIGGER_SOURCE eventSrc
     )
   Summary:
     Setup the DMA channel parameters.
   Description:
     This function sets up the DMA channel parameters.
     It sets the channel priority and enables the mode of operations for the
     current system design.
   Precondition:
     DMA should have been initialized by calling SYS_DMA_Initialize.
     DMA channel should have been allocated by calling SYS_DMA_ChannelAllocate.
   Parameters:
     handle - Handle of the DMA channel as returned by the
                         SYS_DMA_ChannelAllocate function.
     priority - The priority to be associated to the channel.
     modeEnable - The supported operating modes to be enabled.
                         This parameter can be logically ORed to specify
                         multiple options.
     eventSrc - The event causing the cell transfer start.
   Returns:
     None.
   Example:
   <code>
      // 'handle' is a valid handle returned
      // by the SYS_DMA_ChannelAllocate function.
     SYS_DMA_CHANNEL_OP_MODE modeEnable;
     DMA_TRIGGER_SOURCE eventSrc;
     channel = DMA_CHANNEL_2;
     modeEnable = (SYS_DMA_CHANNEL_OP_MODE_BASIC | SYS_DMA_CHANNEL_OP_MODE_CRC);
     eventSrc = DMA_TRIGGER_USART_1_TRANSMIT;
      // Setup channel number, and enables basic and CRC mode
     SYS_DMA_ChannelSetup(handle, modeEnable,eventSrc);
   </code>
   Remarks:
     If SYS_DMA_CHANNEL_OP_MODE_MATCH_ABORT, SYS_DMA_CHANNEL_OP_MODE_CHAIN or
     SYS_DMA_CHANNEL_OP_MODE_CRC mode of operation is enabled, then corresponding
     mode setup API's needs to be called to set the related parameters.
     If the parameter 'eventSrc' is specified as DMA_TRIGGER_SOURCE_NONE then
     SYS_DMA_ChannelForceStart must be called to start the DMA channel transfer.
     Not all features are available on all microcontrollers.
   */

 void
   SYS_DMA_ChannelSetup (
   SYS_DMA_CHANNEL_HANDLE handle ,
   SYS_DMA_CHANNEL_OP_MODE modeEnable ,
   DMA_TRIGGER_SOURCE eventSrc ) ;
 //******************************************************************************
 /* Function:
     void SYS_DMA_ChannelSetupMatchAbortMode
     (
         SYS_DMA_CHANNEL_HANDLE handle,
         uint16_t pattern,
         DMA_PATTERN_LENGTH length,
         SYS_DMA_CHANNEL_IGNORE_MATCH ignore,
         uint8_t ignorePattern
     )
   Summary:
     Setup the pattern match abort mode.
   Description:
     This function sets up the termination of DMA operation when the specified
     pattern is matched. Additionally on supported parts the function also
     sets up the ignoring of part of a pattern(8-bit) from match abort
     pattern(16-bit).
   Precondition:
     DMA should have been initialized by calling SYS_DMA_Initialize.
     DMA channel should have been allocated by calling SYS_DMA_ChannelAllocate.
     The function SYS_DMA_ChannelSetup must be called to enable
     SYS_DMA_CHANNEL_OP_MODE_MATCH_ABORT before setting up pattern
     match mode features.
   Parameters:
     handle - Handle of the DMA channel as returned by the
                         SYS_DMA_ChannelAllocate function.
     pattern - The pattern that needs to be matched to abort a DMA transfer.
     length - Match pattern length can be 1-byte or 2-byte.
     ignore - Enable/Disable a byte between a 2-byte pattern match.
     ignorePattern - The part of the pattern(8-bit) that needs to be ignored
                        from the match abort pattern(16-bit)
   Returns:
     None.
   Example:
   <code>
     // Example 1
     // The following code is for a device with an 8-bit pattern value and no
     // support for pattern match ignore feature
     // 'handle' is a valid handle returned
     // by the SYS_DMA_ChannelAllocate function.
     uint16_t pattern;
     DMA_PATTERN_LENGTH length;
     SYS_DMA_CHANNEL_IGNORE_MATCH ignore;
     uint8_t ignorePattern;
     pattern = 0x00; //Stop transfer on detection of a NULL character
     length = DMA_PATTERN_LENGTH_NONE;
     ignore = SYS_DMA_CHANNEL_IGNORE_MATCH_DISABLE;
     ignorePattern = 0;
     SYS_DMA_ChannelSetupMatchAbortMode(handle, pattern, length,
                                        ignoreEnable, ignorePattern);
     // Example 2
     // The following code is for a device with a 16-bit pattern value and
     // support for pattern match ignore feature
     // 'handle' is a valid handle returned
     // by the SYS_DMA_ChannelAllocate function.
     uint16_t pattern;
     DMA_PATTERN_LENGTH length;
     SYS_DMA_CHANNEL_IGNORE_MATCH ignore;
     uint8_t ignorePattern;
     pattern = 0x0D0A; //Stop transfer on detection of '\r\n'
     length = DMA_PATTERN_MATCH_LENGTH_2BYTES;
     ignore = SYS_DMA_CHANNEL_IGNORE_MATCH_ENABLE;
     ignorePattern = 0x00; \\ Any null character between the termination pattern
                             \\ '\r' and '\n' is ignored.
     SYS_DMA_ChannelSetupMatchAbortMode(handle, pattern, length,
                                             ignore, ignorePattern);
   </code>
   Remarks:
     The parameter 'pattern' (8-bit or 16-bit) is device-specific.
     Not all features are available on all devices.
     Refer to the specific device data sheet for details.
 */

 void
   SYS_DMA_ChannelSetupMatchAbortMode (
   SYS_DMA_CHANNEL_HANDLE handle ,
   uint16_t pattern ,
   DMA_PATTERN_LENGTH length ,
   SYS_DMA_CHANNEL_IGNORE_MATCH ignore ,
   uint8_t ignorePattern ) ;
 //******************************************************************************
 /* Function:
     void SYS_DMA_ChannelCRCSet
     (
         SYS_DMA_CHANNEL_HANDLE handle,
         SYS_DMA_CHANNEL_OPERATION_MODE_CRC crc
     )
   Summary:
     Sets up the CRC operation mode.
   Description:
     This function sets up the CRC computation features.
   Precondition:
     DMA should have been initialized by calling SYS_DMA_Initialize.
     DMA channel should have been allocated by calling SYS_DMA_ChannelAllocate.
     The function SYS_DMA_ChannelSetup must be called to enable
     SYS_DMA_CHANNEL_OP_MODE_CRC before setting up the CRC mode.
   Parameters:
     handle - Handle of the DMA channel as returned by the
                         SYS_DMA_ChannelAllocate function.
     crc.type - CRC will calculate an IP header checksum or an LFSR CRC.
     crc.mode - Compute the CRC in Background/Append mode.
     crc.polyLength - Denotes the length of the polynomial.
     crc.bitOrder - CRC is calculated LSb/MSb first.
     crc.byteOrder - Byte selection order input pre-CRC Generator
     crc.writeOrder - Write byte order selection post-CRC computation
     crc.data - Computed/Seed CRC
     crc.xorBitMask - Enable/Disable XOR bit mask on the corresponding bits
                         when mode is LFSR
   Returns:
     None.
   Example:
   <code>
     //Example 1
     // DMA calculation using the CRC background mode
     // 'handle' is a valid handle returned
     // by the SYS_DMA_ChannelAllocate function.
     SYS_DMA_CHANNEL_OPERATION_MODE_CRC crc;
     crc.type = DMA_CRC_LFSR;
     crc.mode = SYS_DMA_CHANNEL_CRC_MODE_BACKGROUND;
     crc.polyLength = 16;
     crc.bitOrder = DMA_CRC_BIT_ORDER_LSB;
     crc.byteOrder = DMA_CRC_BYTEORDER_NO_SWAPPING;
     crc.writeOrder = SYS_DMA_CRC_WRITE_ORDER_MAINTAIN;
     crc.data = 0xFFFF;
     crc.xorBitMask = 0x1021;
     SYS_DMA_ChannelCRCSet(handle, crc);
   </code>
   Remarks:
     This feature may not be available on all devices. Refer to the specific device
         data sheet to determine availability.
 */

 void
   SYS_DMA_ChannelCRCSet (
   SYS_DMA_CHANNEL_HANDLE handle ,
   SYS_DMA_CHANNEL_OPERATION_MODE_CRC crc ) ;
 //******************************************************************************
 /* Function:
     uint32_t SYS_DMA_ChannelCRCGet(void)
   Summary:
     Returns the computed CRC.
   Description:
     This function returns the computed CRC
   Precondition:
     DMA should have been initialized by calling SYS_DMA_Initialize.
     DMA channel should have been allocated by calling SYS_DMA_ChannelAllocate.
     The function SYS_DMA_ChannelSetup must be called to enable
     SYS_DMA_CHANNEL_OP_MODE_CRC before setting up the CRC mode.
     The CRC generator must have been previously setup using
     SYS_DMA_ChannelCRCSet.
   Parameters:
     None
   Returns:
     uint32_t - The Computed CRC.
   Example:
   <code>
     uint32_t computedCRC;
     computedCRC = SYS_DMA_ChannelCRCGet();
   </code>
   Remarks:
     To get the computed CRC value this function must be called after the block
     transfer completion event (i.e., after getting and processing the callback
     registered with SYS_DMA_ChannelTransferEventHandlerSet).
     This feature may not be available on all devices. Refer to the specific device
         data sheet to determine availability.
 */

 uint32_t
   SYS_DMA_ChannelCRCGet ( void ) ;
 //******************************************************************************
 /* Function:
     void SYS_DMA_ChannelEnable(SYS_DMA_CHANNEL_HANDLE handle)
   Summary:
     Enables a channel.
   Description:
     This function enables a channel.
   Precondition:
     DMA should have been initialized by calling SYS_DMA_Initialize.
     DMA channel should have been allocated by calling SYS_DMA_ChannelAllocate.
     The function SYS_DMA_ChannelSetup must have been called to setup and
     enable the required features.
   Parameters:
     handle - Handle of the DMA channel as returned by the
                         SYS_DMA_ChannelAllocate function.
   Returns:
     None.
   Example:
   <code>
     // 'handle' is a valid handle returned
     // by the SYS_DMA_ChannelAllocate function.
     SYS_DMA_ChannelEnable(handle);
   </code>
   Remarks:
         This function may not required to be called when starting DMA setup
         (by SYS_DMA_ChannelSetup) and transfer Add (by SYS_DMA_ChannelTransferAdd).
         But may be needed to be called in the registered callback to enable the
         channel and continue the data transfer with the existing transfer parameters
         previously set with 'SYS_DMA_ChannelTransferAdd'.
         The DMA channel is by default disabled on the completion of block
         transfer(callback generated)
 */

 void
   SYS_DMA_ChannelEnable (
   SYS_DMA_CHANNEL_HANDLE handle ) ;
 //******************************************************************************
 /* Function:
     void SYS_DMA_ChannelDisable(SYS_DMA_CHANNEL_HANDLE handle)
   Summary:
     Disables a channel.
   Description:
     This function disables a channel.
   Precondition:
     DMA should have been initialized by calling SYS_DMA_Initialize.
     DMA channel should have been allocated by calling SYS_DMA_ChannelAllocate.
     The function SYS_DMA_ChannelSetup must have been called to setup and
     enable the required features.
     A DMA channel should have been enabled either by calling
     'SYS_DMA_ChannelTransferAdd' or 'SYS_DMA_ChannelEnable'
   Parameters:
     handle - Handle of the DMA channel as returned by the
                         SYS_DMA_ChannelAllocate function.
   Returns:
     None.
   Example:
   <code>
     // 'handle' is a valid handle returned
     // by the SYS_DMA_ChannelAllocate function.
     SYS_DMA_ChannelDisable(handle);
   </code>
   Remarks:
     None.
 */

 void
   SYS_DMA_ChannelDisable (
   SYS_DMA_CHANNEL_HANDLE handle ) ;
 //******************************************************************************
 /* Function:
     void SYS_DMA_ChannelTransferAdd
     (
         SYS_DMA_CHANNEL_HANDLE handle,
         const void *srcAddr, size_t srcSize
         const void *destAddr, size_t destSize,
         size_t cellSize
     )
   Summary:
     Adds a data transfer to a DMA channel and Enables the channel to start
     data transfer.
   Description:
     This function adds a data transfer characteristics for a DMA channel. The
     The source and the destination addresses, source and destination lengths,
     The number of bytes transferred per cell event are set. It also enables
     the channel to start data transfer.
     If the requesting client registered an event callback with the service,
     the service will issue a SYS_DMA_TRANSFER_EVENT_COMPLETE or
     SYS_DMA_TRANSFER_EVENT_ABORT event if the transfered was processed
     successfully of SYS_DMA_TRANSFER_EVENT_ERROR event if the transfer was not
     processed successfully.
   Precondition:
     DMA should have been initialized by calling SYS_DMA_Initialize.
     DMA channel should have been allocated by calling SYS_DMA_ChannelAllocate.
     The function SYS_DMA_ChannelSetup must have been called to setup and
     enable the required features.
   Parameters:
      handle - Handle of the DMA channel as returned by the
                        SYS_DMA_ChannelAllocate function.
      srcAddr - Source of the DMA transfer
      srcSize - Size of the source
      destAddr - Destination of the DMA transfer
      destSize - Size of the destination
      cellSize - Size of the cell
   Returns:
     None.
   Example:
     <code>
     // Add 10 bytes of data transfer to UART TX
     // 'handle' is a valid handle returned
     // by the SYS_DMA_ChannelAllocate function.
     MY_APP_OBJ myAppObj;
     uint8_t buf[10];
     void *srcAddr;
     void *destAddr;
     size_t srcSize;
     size_t destSize;
     size_t cellSize;
     srcAddr = (uint8_t *) buf;
     srcSize = 10;
     destAddr = (uin8_t*) &U2TXREG;
     destSize = 1;
     cellSize = 1;
     // User registers an event handler with system service. This is done once
     SYS_DMA_ChannelTransferEventHandlerSet(handle, APP_DMASYSTransferEventHandler,
                                                             (uintptr_t)&myAppObj);
     SYS_DMA_ChannelTransferAdd(handle,srcAddr,srcSize,destAddr,destSize,cellSize);
     if(SYS_DMA_CHANNEL_HANDLE_INVALID == handle)
     {
         // Error handling here
     }
     // Event Processing Technique. Event is received when
     // the transfer is processed.
     void APP_DMASYSTransferEventHandler(SYS_DMA_TRANSFER_EVENT event,
             SYS_DMA_CHANNEL_HANDLE handle, uintptr_t contextHandle)
     {
         switch(event)
         {
             case SYS_DMA_TRANSFER_EVENT_COMPLETE:
                 // This means the data was transferred.
                 break;
             case SYS_DMA_TRANSFER_EVENT_ERROR:
                 // Error handling here.
                 break;
             default:
                 break;
         }
     }
     </code>
   Remarks:
     For PIC32MZ series of devices, if the source/destination addresses are
     RAM memory addresses, the the source/destination buffers
     should be made coherent to avoid the cache coherency issues.
     For example:
         <code>
     uint8_t buffer[1024];
     // The buffer can be made coherent by adding the 'coherent' attribute, as follows:
     uint8_t __attribute__((coherent)) __attribute__((aligned(16))) buffer[1024];
         </code>
 */

 void
   SYS_DMA_ChannelTransferAdd (
   SYS_DMA_CHANNEL_HANDLE handle ,
   const void * srcAddr ,
   size_t srcSize ,
   const void * destAddr ,
   size_t destSize ,
   size_t cellSize ) ;
 //******************************************************************************
 /* Function:
     void SYS_DMA_ChannelTransferSet
     (
         SYS_DMA_CHANNEL_HANDLE handle,
         const void *srcAddr, size_t srcSize
         const void *destAddr, size_t destSize,
         size_t cellSize
     )
   Summary:
     Sets up a data transfer to a DMA channel.
   Description:
     This function sets up data transfer characteristics for a DMA channel. The
     The source and the destination addresses, source and destination lengths,
     The number of bytes transferred per cell event are set.
     This function does not enables the DMA channel. The channel has to be explicitly
     enabled to start the data transfer.
     The above functions could be used in situations where in the user intends to
     setup transfer parameters but do not intend to enable the channel immediately.
     For example to chain to DMA channels in a cyclic order where the channels remains
     disabled. The channel is enabled automatically by the DMA when the transfer trigger
     condition occurs.
   Precondition:
     DMA should have been initialized by calling SYS_DMA_Initialize.
     DMA channel should have been allocated by calling SYS_DMA_ChannelAllocate.
     The function SYS_DMA_ChannelSetup must have been called to setup and
     enable the required features.
   Parameters:
      handle - Handle of the DMA channel as returned by the
                        SYS_DMA_ChannelAllocate function.
      srcAddr - Source of the DMA transfer
      srcSize - Size of the source
      destAddr - Destination of the DMA transfer
      destSize - Size of the destination
      cellSize - Size of the cell
   Returns:
     None.
   Example:
     <code>
     // Set up 10 bytes of data transfer to UART TX
     // 'handle' is a valid handle returned
     // by the SYS_DMA_ChannelAllocate function.
     MY_APP_OBJ myAppObj;
     uint8_t buf[10];
     void *srcAddr;
     void *destAddr;
     size_t srcSize;
     size_t destSize;
     size_t cellSize;
     srcAddr = (uint8_t *) buf;
     srcSize = 10;
     destAddr = (uin8_t*) &U2TXREG;
     destSize = 1;
     cellSize = 1;
     // User registers an event handler with system service. This is done once
     SYS_DMA_ChannelTransferEventHandlerSet(handle, APP_DMASYSTransferEventHandler,
                                                             (uintptr_t)&myAppObj);
     SYS_DMA_ChannelTransferSet(handle,srcAddr,srcSize,destAddr,destSize,cellSize);
     SYS_DMA_ChannelEnable(handle);
     if(SYS_DMA_CHANNEL_HANDLE_INVALID == handle)
     {
         // Error handling here
     }
     // Event Processing Technique. Event is received when
     // the transfer is processed.
     void APP_DMASYSTransferEventHandler(SYS_DMA_TRANSFER_EVENT event,
             SYS_DMA_CHANNEL_HANDLE handle, uintptr_t contextHandle)
     {
         switch(event)
         {
             case SYS_DMA_TRANSFER_EVENT_COMPLETE:
                 // This means the data was transferred.
                 break;
             case SYS_DMA_TRANSFER_EVENT_ERROR:
                 // Error handling here.
                 break;
             default:
                 break;
         }
     }
     </code>
   Remarks:
     For PIC32MZ series of devices, if the source/destination addresses are
     RAM memory addresses, the the source/destination buffers
     should be made coherent to avoid the cache coherency issues.
     For example:
         <code>
     uint8_t buffer[1024];
     // The buffer can be made coherent by adding the 'coherent' attribute, as follows:
     uint8_t __attribute__((coherent)) __attribute__((aligned(16))) buffer[1024];
         </code>
 */

 void
   SYS_DMA_ChannelTransferSet (
   SYS_DMA_CHANNEL_HANDLE handle ,
   const void * srcAddr ,
   size_t srcSize ,
   const void * destAddr ,
   size_t destSize ,
   size_t cellSize ) ;
 //******************************************************************************
 /* Function:
     size_t SYS_DMA_ChannelSourceTransferredSizeGet(SYS_DMA_CHANNEL_HANDLE handle)
   Summary:
     Returns the number of bytes transferred from source.
   Description:
     When a data transfer request is submitted. At any time while the transmission
     is in progress the size of the amount of data transferred from source
     can be known by calling this function.
   Precondition:
     DMA should have been initialized by calling SYS_DMA_Initialize.
     DMA channel should have been allocated by calling SYS_DMA_ChannelAllocate.
     Data transfer should have been initiated by calling SYS_DMA_ChannelTransferAdd or
     SYS_DMA_ChannelTransferSet.
   Parameters:
     handle - A valid channel handle, returned from the system service's
                    Allocate routine
   Returns:
     size_t - Returns the number of bytes transferred from the submitted size.
   Example:
     <code>
     // 'handle' is a valid handle returned
     // by the SYS_DMA_ChannelAllocate function.
     MY_APP_OBJ myAppObj;
     uint8_t buf[10];
     void *srcAddr;
     void *destAddr;
     size_t srcSize;
     size_t destSize;
     size_t cellSize;
     size_t transferredSize;
     srcAddr = (uint8_t *) buf;
     srcSize = 10;
     destAddr = (uin8_t*) &U2TXREG;
     destSize = 1;
     cellSize = 1;
     channelHandle = SYS_DMA_ChannelAllocate(channel);
     // User registers an event handler with system service. This is done once
     SYS_DMA_ChannelTransferEventHandlerSet(handle, APP_DMASYSTransferEventHandler,
                                                             (uintptr_t)&myAppObj);
     SYS_DMA_ChannelTransferAdd(handle,srcAddr,srcSize,destAddr,destSize,cellSize);
     if(SYS_DMA_CHANNEL_HANDLE_INVALID == handle)
     {
         // Error handling here
     }
     // The data is being transferred after adding the transfer to the DMA channel.
     // The user can get to know dynamically the amount of data
     // transmitted from source by calling SYS_DMA_ChannelSourceTransferredSizeGet
     transferredSize = SYS_DMA_ChannelSourceTransferredSizeGet(channelHandle);
     </code>
   Remarks:
     None.
 */

 size_t
   SYS_DMA_ChannelSourceTransferredSizeGet (
   SYS_DMA_CHANNEL_HANDLE handle ) ;
 //******************************************************************************
 /* Function:
      size_t SYS_DMA_ChannelDestinationTransferredSizeGet(SYS_DMA_CHANNEL_HANDLE handle)
   Summary:
     Returns the number of bytes transferred to destination.
   Description:
     When a data transfer request is submitted. At any time while the transmission
     is in progress the size of the amount of data transferred to destination
     can be known by calling this function.
   Precondition:
     DMA should have been initialized by calling SYS_DMA_Initialize.
     DMA channel should have been allocated by calling SYS_DMA_ChannelAllocate.
     Data transfer should have been initiated by calling SYS_DMA_ChannelTransferAdd or
     SYS_DMA_ChannelTransferSet.
   Parameters:
     handle - A valid channel handle, returned from the system service's
                    Allocate routine
   Returns:
     size_t - Returns the number of bytes received from the submitted size.
   Example:
     <code>
     // 'handle' is a valid handle returned
     // by the SYS_DMA_ChannelAllocate function.
     MY_APP_OBJ myAppObj;
     uint8_t buf[10];
     void *srcAddr;
     void *destAddr;
     size_t srcSize;
     size_t destSize;
     size_t cellSize;
     size_t transferredSize;
     srcAddr = (uin8_t*) &U2RXREG;
     srcSize = 1;
     destAddr = (uint8_t *) buf ;
     destSize = 10;
     cellSize = 1;
     channelHandle = SYS_DMA_ChannelAllocate(channel);
     // User registers an event handler with system service. This is done once
     SYS_DMA_ChannelTransferEventHandlerSet(handle, APP_DMASYSTransferEventHandler,
                                                             (uintptr_t)&myAppObj);
     SYS_DMA_ChannelTransferAdd(handle,srcAddr,srcSize,destAddr,destSize,cellSize);
     if(SYS_DMA_CHANNEL_HANDLE_INVALID == handle)
     {
         // Error handling here
     }
     // The data is being transferred after adding the transfer to the DMA channel.
     // The user can get to know dynamically the amount of data
     // transmitted to destination by calling SYS_DMA_ChannelDestinationTransferredSizeGet
     transferredSize = SYS_DMA_ChannelDestinationTransferredSizeGet(channelHandle);
     </code>
   Remarks:
     None.
 */

 size_t
   SYS_DMA_ChannelDestinationTransferredSizeGet (
   SYS_DMA_CHANNEL_HANDLE handle ) ;
 //******************************************************************************
 /*
   Function:
     void SYS_DMA_ChannelTransferEventHandlerSet
     (
         SYS_DMA_CHANNEL_HANDLE handle,
         const SYS_DMA_CHANNEL_TRANSFER_EVENT_HANDLER eventHandler,
         const uintptr_t contextHandle
     )
   Summary:
     This function allows a DMA system service client to set an event handler.
   Description:
     This function allows a client to set an event handler. The client may want
     to receive transfer related events in cases when it uses non-blocking read and
     write functions. The event handler should be set before the client
     intends to perform operations that could generate events.
     This function accepts a contextHandle parameter. This parameter could be
     set by the client to contain (or point to) any client specific data object
     that should be associated with this DMA channel.
   Precondition:
     DMA should have been initialized by calling SYS_DMA_Initialize.
     DMA channel should have been allocated by calling SYS_DMA_ChannelAllocate.
   Parameters:
     handle - A valid channel handle, returned from the system service's
                    Allocate routine
     eventHandler - Pointer to the event handler function.
     contextHandle - Value identifying the context of the application/driver/middleware
            that registered the event handling function.
   Returns:
     None.
   Example:
     <code>
     // 'handle' is a valid handle returned
     // by the SYS_DMA_ChannelAllocate function.
     MY_APP_OBJ myAppObj;
     uint8_t buf[10];
     void *srcAddr;
     void *destAddr;
     size_t srcSize;
     size_t destSize;
     size_t cellSize;
     srcAddr = (uint8_t *) buf;
     srcSize = 10;
     destAddr = (uin8_t*) &U2TXREG;
     destSize = 1;
     cellSize = 1;
     channelHandle = SYS_DMA_ChannelAllocate(channel);
     // User registers an event handler with system service. This is done once
     SYS_DMA_ChannelTransferEventHandlerSet(handle, APP_DMASYSTransferEventHandler,
                                                             (uintptr_t)&myAppObj);
     SYS_DMA_ChannelTransferAdd(handle,srcAddr,srcSize,destAddr,destSize,cellSize);
     if(SYS_DMA_CHANNEL_HANDLE_INVALID == handle)
     {
         // Error handling here
     }
     // Event Processing Technique. Event is received when
     // the transfer is processed.
     void APP_DMASYSTransferEventHandler(SYS_DMA_TRANSFER_EVENT event,
             SYS_DMA_CHANNEL_HANDLE handle, uintptr_t contextHandle)
     {
         switch(event)
         {
             case SYS_DMA_TRANSFER_EVENT_COMPLETE:
                 // This means the data was transferred.
                 break;
             case SYS_DMA_TRANSFER_EVENT_ERROR:
                 // Error handling here.
                 break;
             default:
                 break;
         }
     }
     </code>
   Remarks:
     None.
  */

 void
   SYS_DMA_ChannelTransferEventHandlerSet (
   SYS_DMA_CHANNEL_HANDLE handle ,
   const SYS_DMA_CHANNEL_TRANSFER_EVENT_HANDLER eventHandler ,
   const uintptr_t contextHandle ) ;
 // *****************************************************************************
 /* Function:
     SYS_DMA_ERROR SYS_DMA_ChannelErrorGet(SYS_DMA_CHANNEL_HANDLE handle)
   Summary:
     This function returns the error(if any) associated with the last client
     request.
   Description:
     This function returns the error(if any) associated with the last client
     request. If the service send a SYS_DMA_TRANSFER_EVENT_ERROR to the client,
     the client can call this function to know the error cause.
     The error status will be updated on every operation and should be read
     frequently (ideally immediately after the service operation has completed)
     to know the relevant error status.
   Precondition:
     The SYS_DMA_Initialize routine must have been called for the DMA sub system.
     SYS_DMA_ChannelAllocate must have been called to obtain a valid opened channel
     handle.
   Parameters:
      handle - Handle of the DMA channel as returned by the
                        SYS_DMA_ChannelAllocate function.
   Returns:
     A SYS_DMA_ERROR type indicating last known error status.
   Example:
     <code>
     // 'handle' is a valid handle returned
     // by the SYS_DMA_ChannelAllocate function.
     // pDmaSrc, pDmaDst is the source,destination address
     // txferSrcSize, txferDesSize is the source,destination transfer size
     // cellSize is the cell size
     MY_APP_OBJ myAppObj;
     // Client registers an event handler with service. This is done once
     SYS_DMA_ChannelTransferEventHandlerSet( handle, APP_DMATransferEventHandle,
                                      (uintptr_t)&myAppObj );
     SYS_DMA_ChannelSetup(handle, SYS_DMA_CHANNEL_OP_MODE_BASIC,
                                  DMA_TRIGGER_SOURCE_NONE);
     SYS_DMA_ChannelTransferAdd(handle,pDmaSrc,txferSrcSize,
                                 pDmaDst,txferDesSize,cellSize);
     SYS_DMA_ChannelForceStart(handle);
     if(SYS_DMA_CHANNEL_HANDLE_INVALID == handle)
     {
         // Error handling here
     }
     // Event Processing Technique. Event is received when
     // the transfer is processed.
     void APP_DMATransferEventHandle( SYS_DMA_TRANSFER_EVENT event,
             SYS_DMA_CHANNEL_HANDLE handle, uintptr_t contextHandle )
     {
         switch(event)
         {
             case SYS_DMA_TRANSFER_EVENT_COMPLETE:
                 // This means the data was transferred.
                 break;
             case SYS_DMA_TRANSFER_EVENT_ERROR:
                 // Error handling here.
                 if(SYS_DMA_ERROR_ADDRESS_ERROR == SYS_DMA_ChannelErrorGet(handle))
                 {
                     // There was an address error.
                     // Do error handling here.
                 }
                 break;
             default:
                 break;
         }
     }
     </code>
   Remarks:
     It is the client's responsibility to make sure that the error status is
     obtained frequently. The service will update the error status
     regardless of whether this has been examined by the client.
 */

 SYS_DMA_ERROR
   SYS_DMA_ChannelErrorGet (
   SYS_DMA_CHANNEL_HANDLE handle ) ;
 //******************************************************************************
 /* Function:
     void SYS_DMA_ChannelForceStart(SYS_DMA_CHANNEL_HANDLE handle)
   Summary:
     Force start of transfer on the selected channel.
   Description:
     The function force start a DMA transfer to occur for the selected channel.
   Precondition:
     DMA should have been initialized by calling SYS_DMA_Initialize.
     DMA channel should have been allocated by calling SYS_DMA_ChannelAllocate.
     The function SYS_DMA_ChannelSetup must have been called to setup and
     enable the required features.
     The function 'SYS_DMA_ChannelTransferAdd' to add a transfer.
   Parameters:
      handle - Handle of the DMA channel as returned by the
                        SYS_DMA_ChannelAllocate function.
   Returns:
     None.
   Example:
   <code>
     // 'handle' is a valid handle returned
     // by the SYS_DMA_ChannelAllocate function.
     // pDmaSrc, pDmaDst is the source,destination address
     // txferSrcSize, txferDesSize is the source,destination transfer size
     // cellSize is the cell size
     MY_APP_OBJ myAppObj;
     // Client registers an event handler with service. This is done once
     SYS_DMA_ChannelTransferEventHandlerSet( handle, APP_DMATransferEventHandle,
                                      (uintptr_t)&myAppObj );
     SYS_DMA_ChannelSetup(handle, SYS_DMA_CHANNEL_OP_MODE_BASIC,
                                  DMA_TRIGGER_SOURCE_NONE);
     SYS_DMA_ChannelTransferAdd(handle,pDmaSrc,txferSrcSize,
                                 pDmaDst,txferDesSize,cellSize);
     SYS_DMA_ChannelForceStart(handle);
     if(SYS_DMA_CHANNEL_HANDLE_INVALID == handle)
     {
         // Error handling here
     }
     // Event Processing Technique. Event is received when
     // the transfer is processed.
     void APP_DMATransferEventHandle( SYS_DMA_TRANSFER_EVENT event,
             SYS_DMA_CHANNEL_HANDLE handle, uintptr_t contextHandle )
     {
         switch(event)
         {
             case SYS_DMA_TRANSFER_EVENT_COMPLETE:
                 // This means the data was transferred.
                 break;
             case SYS_DMA_TRANSFER_EVENT_ERROR:
                 // Error handling here.
                 if(SYS_DMA_ERROR_ADDRESS_ERROR == DRV_I2S_ErrorGet(myI2SHandle))
                 {
                     // There was an address error.
                     // Do error handling here.
                 }
                 break;
             default:
                 break;
         }
     }
   </code>
   Remarks:
    This function must be used to start the DMA transfer when the channel has been
    setup(by calling SYS_DMA_ChannelSetup) with the eventSrc as DMA_TRIGGER_SOURCE_NONE.
 */

 void
   SYS_DMA_ChannelForceStart (
   SYS_DMA_CHANNEL_HANDLE handle ) ;
 //******************************************************************************
 /* Function:
     void SYS_DMA_ChannelForceAbort(SYS_DMA_CHANNEL_HANDLE handle)
   Summary:
     Force abort of transfer on the selected channel.
   Description:
     The function aborts a DMA transfer to occur for the selected channel.
   Precondition:
     DMA should have been initialized by calling SYS_DMA_Initialize.
     DMA channel should have been allocated by calling SYS_DMA_ChannelAllocate.
     The function SYS_DMA_ChannelSetup must have been called to setup and
     enable the required features.
     The function 'SYS_DMA_ChannelTransferAdd' to add a transfer.
   Parameters:
      handle - Handle of the DMA channel as returned by the
                        SYS_DMA_ChannelAllocate function.
   Returns:
     None.
   Example:
   <code>
     // 'handle' is a valid handle returned
     // by the SYS_DMA_ChannelAllocate function.
     // pDmaSrc, pDmaDst is the source,destination address
     // txferSrcSize, txferDesSize is the source,destination transfer size
     // cellSize is the cell size
     MY_APP_OBJ myAppObj;
     // Client registers an event handler with service. This is done once
     SYS_DMA_ChannelTransferEventHandlerSet( handle, APP_DMATransferEventHandle,
                                      (uintptr_t)&myAppObj );
     SYS_DMA_ChannelSetup(handle, SYS_DMA_CHANNEL_OP_MODE_BASIC,
                                  DMA_TRIGGER_SOURCE_NONE);
     SYS_DMA_ChannelTransferAdd(handle,pDmaSrc,txferSrcSize,
                                 pDmaDst,txferDesSize,cellSize);
     SYS_DMA_ChannelForceStart(handle);
     if(SYS_DMA_CHANNEL_HANDLE_INVALID == handle)
     {
         // Error handling here
     }
     ....
     ....
     // Client may need to abort a transfer
     SYS_DMA_ChannelForceAbort(handle);
     // Event Processing Technique. Event is received when
     // the transfer is processed.
     void APP_DMATransferEventHandle( SYS_DMA_TRANSFER_EVENT event,
             SYS_DMA_CHANNEL_HANDLE handle, uintptr_t contextHandle )
     {
         switch(event)
         {
             case SYS_DMA_TRANSFER_EVENT_ABORT:
                 // This means the data was transferred.
                 break;
             case SYS_DMA_TRANSFER_EVENT_ERROR:
                 // Error handling here.
                 if(SYS_DMA_ERROR_ADDRESS_ERROR == DRV_I2S_ErrorGet(myI2SHandle))
                 {
                     // There was an address error.
                     // Do error handling here.
                 }
                 break;
             default:
                 break;
         }
     }
   </code>
   Remarks:
    This function must be used to abort the DMA transfer when the channel has been
    setup(by calling SYS_DMA_ChannelSetup) with the eventSrc as DMA_TRIGGER_SOURCE_NONE.
    and SYS_DMA_ChannelAbortEventSet has not been called.
 */

 void
   SYS_DMA_ChannelForceAbort (
   SYS_DMA_CHANNEL_HANDLE handle ) ;
 //******************************************************************************
 /* Function:
     void SYS_DMA_ChannelAbortEventSet
     (
         SYS_DMA_CHANNEL_HANDLE handle,
         DMA_TRIGGER_SOURCE eventSrc
     )
   Summary:
     Sets an event source and enables cell transfer abort event for the same
     for the selected channel.
   Description:
     This functions enables a cell transfer abort event for the selected source
     event.
   Precondition:
     DMA should have been initialized by calling SYS_DMA_Initialize.
     DMA channel should have been allocated by calling SYS_DMA_ChannelAllocate.
     The function SYS_DMA_ChannelSetup must have been called to setup and
     enable the required features.
     The function 'SYS_DMA_ChannelTransferAdd' to add a transfer.
   Parameters:
      handle - Handle of the DMA channel as returned by the
                        SYS_DMA_ChannelAllocate function.
      eventSrc - The event causing the cell transfer abort
   Returns:
     None.
   Example:
   <code>
     // 'handle' is a valid handle returned
     // by the SYS_DMA_ChannelAllocate function.
     // pDmaSrc, pDmaDst is the source,destination address
     // txferSrcSize, txferDesSize is the source,destination transfer size
     // cellSize is the cell size
     MY_APP_OBJ myAppObj;
     // Client registers an event handler with service. This is done once
     SYS_DMA_ChannelTransferEventHandlerSet( handle, APP_DMATransferEventHandle,
                                      (uintptr_t)&myAppObj );
     SYS_DMA_ChannelSetup(handle, SYS_DMA_CHANNEL_OP_MODE_BASIC,
                                  DMA_TRIGGER_SOURCE_NONE);
     SYS_DMA_ChannelTransferAdd(handle,pDmaSrc,txferSrcSize,
                                 pDmaDst,txferDesSize,cellSize);
     SYS_DMA_ChannelAbortEventSet(handle, DMA_TRIGGER_CTMU);
     SYS_DMA_ChannelForceStart(handle);
     if(SYS_DMA_CHANNEL_HANDLE_INVALID == handle)
     {
         // Error handling here
     }
     // Event Processing Technique. Event is received when
     // the transfer is processed.
     void APP_DMATransferEventHandle( SYS_DMA_TRANSFER_EVENT event,
             SYS_DMA_CHANNEL_HANDLE handle, uintptr_t contextHandle )
     {
         switch(event)
         {
             case SYS_DMA_TRANSFER_EVENT_ABORT:
                 // This means the data was transferred.
                 break;
             case SYS_DMA_TRANSFER_EVENT_ERROR:
                 // Error handling here.
                 if(SYS_DMA_ERROR_ADDRESS_ERROR == DRV_I2S_ErrorGet(myI2SHandle))
                 {
                     // There was an address error.
                     // Do error handling here.
                 }
                 break;
             default:
                 break;
         }
     }
   </code>
   Remarks:
     If the parameter 'eventSrc' is specified as DMA_TRIGGER_SOURCE_NONE the
     current DMA transfer will be aborted. The behavior is a same as calling
     SYS_DMA_ChannelForceAbort.
 */

 void
   SYS_DMA_ChannelAbortEventSet (
   SYS_DMA_CHANNEL_HANDLE handle ,
   DMA_TRIGGER_SOURCE eventSrc ) ;
 //******************************************************************************
 /* Function:
     bool SYS_DMA_ChannelIsBusy(SYS_DMA_CHANNEL_HANDLE handle)
   Summary:
     Returns the busy status of the specified DMA channel.
   Description:
     This function returns the busy status of the selected DMA channel
   Precondition:
     DMA should have been initialized by calling SYS_DMA_Initialize.
     DMA channel should have been allocated by calling SYS_DMA_ChannelAllocate.
   Parameters:
     handle - Handle of the DMA channel as returned by the
                        SYS_DMA_ChannelAllocate function.
   Returns:
     bool - true, if the selected DMA channel is active or enabled
                  - false, if the selected DMA channel is inactive or disabled
   Example:
   <code>
     bool busyStat;
     busyStat = SYS_DMA_ChannelGetBusy(handle);
   </code>
   Remarks:
     This feature may not be available on all devices. Refer to the specific device
         data sheet to determine availability.
 */

 bool
   SYS_DMA_ChannelIsBusy (
   SYS_DMA_CHANNEL_HANDLE handle ) ;
 //******************************************************************************
 /* Function:
     void SYS_DMA_ChannelSuspend(SYS_DMA_CHANNEL_HANDLE handle)
   Summary:
     Suspend DMA operation on the specified DMA channel.
   Description:
     This function suspends the DMA operation on the DMA channel
     specified by the channel handle.
   Precondition:
     DMA should have been initialized by calling SYS_DMA_Initialize.
     DMA channel should have been allocated by calling SYS_DMA_ChannelAllocate.
   Parameters:
     handle - Handle of the DMA channel as returned by the
                        SYS_DMA_ChannelAllocate function.
   Returns:
     None.
   Example:
   <code>
     SYS_DMA_ChannelSuspend(handle);
   </code>
   Remarks:
     This feature may not be available on all devices. Refer to the specific device
         data sheet to determine availability.
 */

 void
   SYS_DMA_ChannelSuspend (
   SYS_DMA_CHANNEL_HANDLE handle ) ;
 //******************************************************************************
 /* Function:
     void SYS_DMA_ChannelResume(SYS_DMA_CHANNEL_HANDLE handle)
   Summary:
     Resume DMA operation on the specified DMA channel.
   Description:
     This function resumes the DMA operation on the DMA channel
     specified by the channel handle.
   Precondition:
     DMA should have been initialized by calling SYS_DMA_Initialize.
     DMA channel should have been allocated by calling SYS_DMA_ChannelAllocate.
   Parameters:
     handle - Handle of the DMA channel as returned by the
                        SYS_DMA_ChannelAllocate function.
   Returns:
     None.
   Example:
   <code>
     SYS_DMA_ChannelResume(handle);
   </code>
   Remarks:
     This feature may not be available on all devices. Refer to the specific device
         data sheet to determine availability.
 */

 void
   SYS_DMA_ChannelResume (
   SYS_DMA_CHANNEL_HANDLE handle ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: Global DMA Management Functions
 // *****************************************************************************
 // *****************************************************************************
 //******************************************************************************
 /* Function:
     void SYS_DMA_Suspend(void)
   Summary:
     Suspend DMA transfers.
   Description:
     This function suspends DMA transfers to allow CPU uninterrupted access
     to data bus
   Precondition:
     DMA should have been initialized by calling SYS_DMA_Initialize.
   Parameters:
    None.
   Returns:
     None.
   Example:
   <code>
     SYS_DMA_Suspend();
   </code>
   Remarks:
     None
 */

 void
   SYS_DMA_Suspend ( void ) ;
 //******************************************************************************
 /* Function:
     void SYS_DMA_Resume(void)
   Summary:
     Resume DMA operations.
   Description:
     This function disables DMA suspend. It resumes the DMA operation suspended
     by calling SYS_DMA_Suspend. The DMA operates normally.
   Precondition:
     DMA should have been initialized by calling SYS_DMA_Initialize.
   Parameters:
    None.
   Returns:
     None.
   Example:
   <code>
     SYS_DMA_Resume();
   </code>
   Remarks:
     None
 */

 void
   SYS_DMA_Resume ( void ) ;
 //******************************************************************************
 /* Function:
     bool SYS_DMA_IsBusy(void)
   Summary:
     Returns the busy status of the DMA module.
   Description:
     This function returns the busy status of the DMA module
   Precondition:
     DMA should have been initialized by calling SYS_DMA_Initialize.
   Parameters:
    None.
   Returns:
     Boolean
         - true - The DMA module is active
     - false - The DMA module is inactive and disabled
   <code>
     bool busyStat;
     busyStat = SYS_DMA_IsBusy();
   </code>
   Remarks:
     This feature may not be available on all devices. Refer to the specific device
         data sheet to determine availability.
 */

 bool
   SYS_DMA_IsBusy ( void ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: Deprecated functions
 // *****************************************************************************
 // *****************************************************************************
 //*******************************************************************************
 /* Function:
     void SYS_DMA_TasksISR(SYS_MODULE_OBJ object, DMA_CHANNEL activeChannel)
   Summary:
     This function is deprecated. Use SYS_DMA_Tasks function.
  */

 void
   SYS_DMA_Tasks (
   SYS_MODULE_OBJ object ,
   DMA_CHANNEL activeChannel ) ;
 //*****************************************************************************
 /* Function:
     void SYS_DMA_TasksError(SYS_MODULE_OBJ object)
   Summary:
     This function is deprecated. Use SYS_DMA_Tasks function.
  */

 void
   SYS_DMA_TasksError (
   SYS_MODULE_OBJ object ) ;
 //*******************************************************************************
 /* Function:
     void SYS_DMA_TasksErrorISR(SYS_MODULE_OBJ object, DMA_CHANNEL activeChannel)
   Summary:
     This function is deprecated. Use SYS_DMA_Tasks function.
  */

 void
   SYS_DMA_TasksErrorISR (
   SYS_MODULE_OBJ object ,
   DMA_CHANNEL activeChannel ) ;
        // #ifndef _SYS_DMA_H
 /*******************************************************************************
  End of File
 */

 #endif /*00 C:\microchip\harmony\v2_06\framework\system\dma\sys_dma.h*/
 /*   CLOSE_FILE Include File */

 // DOM-IGNORE-BEGIN
 // DOM-IGNORE-END
 // *****************************************************************************
 // *****************************************************************************
 // Section: Data Types
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Driver USART Module Index
   Summary:
     USART driver index definitions
   Description:
     These constants provide USART driver index definitions.
   Remarks:
     These constants should be used in place of hard-coded numeric literals.
     These values should be passed into the DRV_USART_Initialize and
     DRV_USART_Open routines to identify the driver instance in use.
 */
 #define DRV_USART_INDEX_0 0
 #define DRV_USART_INDEX_1 1
 #define DRV_USART_INDEX_2 2
 #define DRV_USART_INDEX_3 3
 #define DRV_USART_INDEX_4 4
 #define DRV_USART_INDEX_5 5
 // *****************************************************************************
 /* USART Driver Module Count
   Summary:
     Number of valid USART drivers
   Description:
     This constant identifies the maximum number of USART Driver instances that
     should be defined in the system. Defining more instances than this
     constant will waste RAM memory space.
     This constant can also be used by the system and application to identify the
     number of USART instances on this microcontroller.
   Remarks:
     This value is part-specific.
 */
 #define DRV_USART_COUNT USART_NUMBER_OF_MODULES
 // *****************************************************************************
 /* USART Driver Write Error
   Summary:
     USART Driver Write Error.
   Description:
     This constant is returned by DRV_USART_Write() function when an error
     occurs.
   Remarks:
     None.
 */
 #define DRV_USART_WRITE_ERROR ( ( uint32_t ) ( - 1 ) )
 // *****************************************************************************
 /* USART Driver Read Error
   Summary:
     USART Driver Read Error.
   Description:
     This constant is returned by DRV_USART_Read() function when an error
     occurs.
   Remarks:
     None.
 */
 #define DRV_USART_READ_ERROR ( ( uint32_t ) ( - 1 ) )
 // *****************************************************************************
 /* USART Driver Buffer Handle
   Summary:
     Handle identifying a read or write buffer passed to the driver.
   Description:
     A buffer handle value is returned by a call to the DRV_USART_BufferAddRead
     or DRV_USART_BufferAddWrite functions. This handle is associated with the
     buffer passed into the function and it allows the application to track the
     completion of the data from (or into) that buffer. The buffer handle value
     returned from the "buffer add" function is returned back to the client
     by the "event handler callback" function registered with the driver.
     The buffer handle assigned to a client request expires when the client has
     been notified of the completion of the buffer transfer (after event handler
     function that notifies the client returns) or after the buffer has been
     retired by the driver if no event handler callback was set.
   Remarks:
     None
 */

 typedef
 uintptr_t
   DRV_USART_BUFFER_HANDLE ;
 // *****************************************************************************
 /* USART Driver Invalid Buffer Handle
   Summary:
     Definition of an invalid buffer handle.
   Description:
     This is the definition of an invalid buffer handle. An invalid buffer handle
     is returned by DRV_USART_BufferAddRead and DRV_USART_BufferAddWrite
     functions if the buffer add request was not successful.
   Remarks:
     None
 */
 #define DRV_USART_BUFFER_HANDLE_INVALID ( ( DRV_USART_BUFFER_HANDLE ) ( - 1 ) )
 // *****************************************************************************
 /* USART Modes of Operation
   Summary:
     Identifies the modes of the operation of the USART module
   Description:
     This data type identifies the modes of the operation of the USART module.
   Remarks:
     Not all modes are available on all devices. Refer to the specific device data
     sheet to determine availability.
 */

 typedef
   enum
   {
     /* USART works in IRDA mode */
     DRV_USART_OPERATION_MODE_IRDA ,
     /* This is the normal point to point communication mode where the USART
     communicates directly with another USART by connecting it's Transmit signal
     to the external USART's Receiver signal and vice versa. An external
     transceiver may be connected to obtain RS-232 signal levels. This type of
     connection is typically full duplex. */
     DRV_USART_OPERATION_MODE_NORMAL ,
     /* This is a multi-point bus mode where the USART can communicate with
     many other USARTS on a bus using an address-based protocol such as RS-485.
     This mode is typically half duplex and the physical layer may require a
     transceiver. In this mode every USART on the bus is assigned an address and
     the number of data bits is 9 bits */
     DRV_USART_OPERATION_MODE_ADDRESSED ,
     /* Loopback mode internally connects the Transmit signal to the Receiver
      signal, looping data transmission back into this USART's own input. It is
      useful primarily as a test mode. */
     DRV_USART_OPERATION_MODE_LOOPBACK
   } DRV_USART_OPERATION_MODE ;
 // *****************************************************************************
 /* USART Driver Buffer Events
    Summary
     Identifies the possible events that can result from a buffer add request.
    Description
     This enumeration identifies the possible events that can result from a
     buffer add request caused by the client calling either the
     DRV_USART_BufferAddRead or DRV_USART_BufferAddWrite functions.
    Remarks:
     One of these values is passed in the "event" parameter of the event
     handling callback function that the client registered with the driver by
     calling the DRV_USART_BufferEventHandlerSet function when a buffer
     transfer request is completed.
 */

 typedef
   enum
   {
     /* All data from or to the buffer was transferred successfully. */
     DRV_USART_BUFFER_EVENT_COMPLETE ,
     /* There was an error while processing the buffer transfer request. */
     DRV_USART_BUFFER_EVENT_ERROR ,
     /* Data transfer aborted (Applicable in DMA mode) */
     DRV_USART_BUFFER_EVENT_ABORT
   } DRV_USART_BUFFER_EVENT ;
 // *****************************************************************************
 /* USART Driver Buffer Result
    Summary
     Identifies the possible result of the buffer processing.
    Description
     This enumeration identifies the possible result of the buffer processing.

    Remarks:
     DRV_USART_BUFFER_RESULT_HANDLE_EXPIRED is the state of the buffer which
     is in the free buffer pool.
 */

 typedef
   enum
   {
     /* Buffer handle is not valid*/
     DRV_USART_BUFFER_RESULT_HANDLE_INVALID ,
     /* Buffer handle has expired. */
     DRV_USART_BUFFER_RESULT_HANDLE_EXPIRED ,
     /* Buffer is removed from the queue succesfully*/
     DRV_USART_BUFFER_RESULT_REMOVED_SUCCESFULLY ,
     /* Buffer removal failed because of unable to acquire the mutex
      * This is applicable in RTOS mode only */
     DRV_USART_BUFFER_RESULT_REMOVAL_FAILED
   } DRV_USART_BUFFER_RESULT ;
 // *****************************************************************************
 /* USART Driver Buffer Event Handler Function Pointer
    Summary
     Pointer to a USART Driver Buffer Event handler function
    Description
     This data type defines the required function signature for the USART driver
     buffer event handling callback function. A client must register a pointer
     to a buffer event handling function whose function signature (parameter
     and return value types) match the types specified by this function pointer
     in order to receive buffer related event calls back from the driver.
     The parameters and return values and are described here and
     a partial example implementation is provided.
   Parameters:
     event - Identifies the type of event
     bufferHandle - Handle identifying the buffer to which the vent relates
     context - Value identifying the context of the application that registered
                       the event handling function.
   Returns:
     None.
   Example:
     <code>
     void APP_MyBufferEventHandler( DRV_USART_BUFFER_EVENT event,
                                    DRV_USART_BUFFER_HANDLE bufferHandle,
                                    uintptr_t context )
     {
         MY_APP_DATA_STRUCT pAppData = (MY_APP_DATA_STRUCT) context;
         switch(event)
         {
             case DRV_USART_BUFFER_EVENT_COMPLETE:
                 // Handle the completed buffer.
                 break;
             case DRV_USART_BUFFER_EVENT_ERROR:
             default:
                 // Handle error.
                 break;
         }
     }
     </code>
   Remarks:
     If the event is DRV_USART_BUFFER_EVENT_COMPLETE, it means that the data was
     transferred successfully.
     If the event is DRV_USART_BUFFER_EVENT_ERROR, it means that the data was not
     transferred successfully. The DRV_USART_ErrorGet function can be called to
     know the error. The DRV_USART_BufferCompletedBytesGet function can be
     called to find out how many bytes were processed.
     The bufferHandle parameter contains the buffer handle of the buffer that
     associated with the event.
     The context parameter contains the a handle to the client context,
     provided at the time the event handling function was registered using the
     DRV_USART_BufferEventHandlerSet function. This context handle value is
     passed back to the client as the "context" parameter. It can be any value
     necessary to identify the client context or instance (such as a pointer to
     the client's data) instance of the client that made the buffer add request.
     The event handler function executes in the driver peripheral's interrupt
     context when the driver is configured for interrupt mode operation. It is
     recommended of the application to not perform process intensive or blocking
     operations with in this function.
     The DRV_USART_BufferAddRead and DRV_USART_BufferAddWrite functions can
     be called in the event handler to add a buffer to the driver queue. These
     functions can only be called to add buffers to the driver whose event
     handler is running. For example, buffers cannot be added USART2 driver in
     USART1 driver event handler.
 */

 typedef
 void ( * DRV_USART_BUFFER_EVENT_HANDLER ) ( DRV_USART_BUFFER_EVENT event ,
 DRV_USART_BUFFER_HANDLE bufferHandle ,
 uintptr_t context ) ;
 // *****************************************************************************
 /* USART Driver Byte Event Handler Function Pointer
    Summary
     Pointer to a USART Driver Byte Event handler function
    Description
    This data type defines the required function signature for the USART driver
    byte event handling callback function. A client must register a pointer to a
    byte event handling function whose function signature (parameter and return
    value types) match the types specified by this function pointer in order to
    receive byte related event calls back from the driver.
   Parameters:
     index - Identifier for the instance
   Returns:
     None.
   Example:
     <code>
     void APP_MyUsartTxEventHandler(void)
     {
         // Handle the transmit byte event
     }
     </code>
   Remarks:
     The event handler function executes in the driver peripheral's interrupt
     context when the driver is configured for interrupt mode operation. It is
     recommended that the application not perform process intensive or blocking
     operations with in this function.
 */

 typedef
 void ( * DRV_USART_BYTE_EVENT_HANDLER ) ( const SYS_MODULE_INDEX index ) ;
 // *****************************************************************************
 /* USART Handshake Modes
   Summary:
     Identifies the handshaking modes supported by the USART driver.
   Description:
     This data type identifies the handshaking modes supported by the USART
     driver.
   Remarks:
     Not all modes are available on all devices. Refer to the specific device data
     sheet to determine availability.
 */

 typedef
   enum
   {
     /* Handshaking occurs in Flow Control Mode */
     DRV_USART_HANDSHAKE_FLOWCONTROL = /*DOM-IGNORE-BEGIN*/
     USART_HANDSHAKE_MODE_FLOW_CONTROL                                                        /*DOM-IGNORE-END*/
     ,
     /* Handshaking occurs in Simplex Mode */
     DRV_USART_HANDSHAKE_SIMPLEX = /*DOM-IGNORE-BEGIN*/
     USART_HANDSHAKE_MODE_SIMPLEX                                                  /*DOM-IGNORE-END*/
     ,
     /* No Handshaking */
     DRV_USART_HANDSHAKE_NONE = /*DOM-IGNORE-BEGIN*/
     2                                                 /*DOM-IGNORE-END*/
   } DRV_USART_HANDSHAKE ;
 // *****************************************************************************
 /* USART Baud Set Result
   Summary:
     Identifies the results of the baud set function.
   Description:
     This data type identifies the results of the DRV_USART_BaudSet function.
   Remarks:
     None.
 */

 typedef
   enum
   {
     /* The driver was not able to change the baud */
     DRV_USART_BAUD_SET_ERROR = /*DOM-IGNORE-BEGIN*/
     - 1                                                /*DOM-IGNORE-END*/
     ,
     /* The driver was able to change the baud successfully */
     DRV_USART_BAUD_SET_SUCCESS
   } DRV_USART_BAUD_SET_RESULT ;
 // *****************************************************************************
 /* USART Line Control Set Result
   Summary:
     Identifies the results of the baud set function.
   Description:
     This data type identifies the results of the DRV_USART_LineControlSet
     function.
   Remarks:
     None.
 */

 typedef
   enum
   {
     /* The driver was not able to change the Line Control */
     DRV_USART_LINE_CONTROL_SET_ERROR = /*DOM-IGNORE-BEGIN*/
     - 1                                                        /*DOM-IGNORE-END*/
     ,
     /* The driver was able to change the Line Control successfully */
     DRV_USART_LINE_CONTROL_SET_SUCCESS
   } DRV_USART_LINE_CONTROL_SET_RESULT ;
 // *****************************************************************************
 /* USART Line Control Modes
   Summary:
     Identifies the line control modes supported by the USART driver.
   Description:
     This data type identifies the line control modes supported by the USART
     driver. Line control modes define the number of data bits, parity mode, and
     the number of stop bits in a USART transmit and receive frames.
   Remarks:
     The abbreviations used in the labels for the values of this enumeration
     follow the format <data><parity><stop>, where:
     <data> is the number of data bits
     <parity> is either "NONE" (for no parity), "EVEN" for 1 parity bit
                 added to obtain an even number of bits, or "ODD" for one bit
                 added to obtain an odd number of bits.
     <stop> is the number of Stop bits
 */

 typedef
   enum
   {
     /* 8 data bits, no parity bit, 1 stop bit */
     DRV_USART_LINE_CONTROL_8NONE1 = /*DOM-IGNORE-BEGIN*/
     USART_8N1                                                      /* DOM-IGNORE-END*/
     ,
     /* 9 data bits, no parity bit, 1 stop bit */
     DRV_USART_LINE_CONTROL_9NONE1 = /*DOM-IGNORE-BEGIN*/
     USART_9N1                                                      /* DOM-IGNORE-END*/
     ,
     /* 8 data bits, 1 bit for even parity, 1 stop bit */
     DRV_USART_LINE_CONTROL_8EVEN1 = /*DOM-IGNORE-BEGIN*/
     USART_8E1                                                      /* DOM-IGNORE-END*/
     ,
     /* 8 data bits, 1 bit for even parity, 2 stop bits */
     DRV_USART_LINE_CONTROL_8EVEN2 = /*DOM-IGNORE-BEGIN*/
     USART_8E2                                                      /* DOM-IGNORE-END*/
     ,
     /* 8 data bits, 1 bit for odd parity, 1 stop bit */
     DRV_USART_LINE_CONTROL_8ODD1 = /*DOM-IGNORE-BEGIN*/
     USART_8O1                                                     /* DOM-IGNORE-END*/
     ,
     /* 8 data bits, 1 bit for odd parity, 2 stop bits */
     DRV_USART_LINE_CONTROL_8ODD2 = /*DOM-IGNORE-BEGIN*/
     USART_8O2                                                     /* DOM-IGNORE-END*/
     ,
     /* 8 data bits, no parity bit, 2 stop bit */
     DRV_USART_LINE_CONTROL_8NONE2 = /*DOM-IGNORE-BEGIN*/
     USART_8N2                                                      /* DOM-IGNORE-END*/
     ,
     /* 9 data bits, no parity bit, 2 stop bit */
     DRV_USART_LINE_CONTROL_9NONE2 = /*DOM-IGNORE-BEGIN*/
     USART_9N2                                                      /* DOM-IGNORE-END*/
   } DRV_USART_LINE_CONTROL ;
 // *****************************************************************************
 /* USART Initialization flags
   Summary:
     Flags identifying features that can be enabled when the driver is
     initialized.
   Description:
     This enumeration defines flags identifying features that can be enabled
     when the driver is initialized.
   Remarks:
     These flags can be logically ORed together. They are passed into the
     DRV_USART_Initialize function through the "flags" member of the
     DRV_USART_INIT structure.
 */

 typedef
   enum
   {
     /* Use this if no flags need to be set */
     DRV_USART_INIT_FLAG_NONE = /* DOM-IGNORE-BEGIN */
     0                                                  /*DOM-IGNORE-END*/
     ,
     /* Flag to enable "wake on start" operation. If supported and enabled,
        this feature will allow the USART to wake-up the device when a
        Start bit is received. This option should be selected only when the
        device is to placed in Sleep mode. Note that enabling this bit will
        also cause the first received character to be lost. Refer to the specific
        device data sheet for more information. */
     DRV_USART_INIT_FLAG_WAKE_ON_START /*DOM-IGNORE-BEGIN*/
     = ( 1 << 0 )                                                      /*DOM-IGNORE-END*/
       ,
     /* Flag to enable auto baud detection. If supported and enabled, this
        feature will allow the USART to automatically detect the baud rate in
        use. */
       DRV_USART_INIT_FLAG_AUTO_BAUD/*DOM-IGNORE-BEGIN*/
     = ( 1 << 1 )                                                  /*DOM-IGNORE-END*/
       ,
     /* Flag to enable stop in idle. If supported and enabled , this
        feature will allow the USART to stop when the CPU enters Idle
        mode */
       DRV_USART_INIT_FLAG_STOP_IN_IDLE/* DOM-IGNORE-BEGIN*/
     = ( 1 << 2 )                                                      /*DOM-IGNORE-END*/
   } DRV_USART_INIT_FLAGS ;
 // *****************************************************************************
 /* Operation Mode Initialization Data
   Summary:
     Defines the initialization data required for different operation modes of
     USART.
   Description:
     This data type defines the initialization data required for different
     operation modes of the USART.
   Remarks:
     None
 */

 typedef
   union
   {
     /* Initialization for Addressed mode */
     struct
     {
         /* Address of the device. */
       uint8_t address ;
     } AddressedModeInit ;
   } DRV_USART_OPERATION_MODE_DATA ;
 // *****************************************************************************
 /* USART Driver Errors.
   Summary:
     Defines the possible errors that can occur during driver operation.
   Description:
     This data type defines the possible errors that can occur when occur during
     USART driver operation. These values are returned by DRV_USART_ErrorGet
     function.
   Remarks:
     None
 */

 typedef
   enum
   {
     /* There was no error */
     DRV_USART_ERROR_NONE
             /*DOM-IGNORE-BEGIN*/
     = USART_ERROR_NONE                              /*DOM-IGNORE-END*/
     ,
     /* This indicates that a parity error has occurred */
     DRV_USART_ERROR_PARITY
             /*DOM-IGNORE-BEGIN*/
     = USART_ERROR_PARITY                              /*DOM-IGNORE-END*/
     ,
     /* This indicates that a framing error has occurred */
     DRV_USART_ERROR_FRAMING
             /*DOM-IGNORE-BEGIN*/
     = USART_ERROR_FRAMING                              /*DOM-IGNORE-END*/
     ,
     /* This indicates a receiver overflow has occurred */
     DRV_USART_ERROR_RECEIVE_OVERRUN
             /*DOM-IGNORE-BEGIN*/
     = USART_ERROR_RECEIVER_OVERRUN                              /*DOM-IGNORE-END*/
     ,
     /* Channel address error (Applicable in DMA mode) */
     DRV_USART_ERROR_ADDRESS /*DOM-IGNORE-BEGIN*/
     = ( 1 << 4 )                                            /* DOM-IGNORE-END*/
   } DRV_USART_ERROR ;
 // *****************************************************************************
 /* USART Client-Specific Driver Status
   Summary:
     Defines the client-specific status of the USART driver.
   Description:
     This enumeration defines the client-specific status codes of the USART
     driver.
   Remarks:
     Returned by the DRV_USART_ClientStatus function.
 */

 typedef
   enum
   {
     /* An error has occurred.*/
     DRV_USART_CLIENT_STATUS_ERROR = DRV_CLIENT_STATUS_ERROR ,
     /* The driver is closed, no operations for this client are ongoing,
     and/or the given handle is invalid. */
     DRV_USART_CLIENT_STATUS_CLOSED = DRV_CLIENT_STATUS_CLOSED ,
     /* The driver is currently busy and cannot start additional operations. */
     DRV_USART_CLIENT_STATUS_BUSY = DRV_CLIENT_STATUS_BUSY ,
     /* The module is running and ready for additional operations */
     DRV_USART_CLIENT_STATUS_READY = DRV_CLIENT_STATUS_READY
   } DRV_USART_CLIENT_STATUS ;
 // *****************************************************************************
 /* USART Driver Transfer Flags
   Summary
     Specifies the status of the receive or transmit
   Description
     This type specifies the status of the receive or transmit operation.
   Remarks:
     More than one of these values may be OR'd together to create a complete
     status value. To test a value of this type, the bit of interest must be
     ANDed with the value and checked to see if the result is non-zero.
 */

 typedef
   enum
   {
     /* Indicates that at least one byte of Data has been received */
     DRV_USART_TRANSFER_STATUS_RECEIVER_DATA_PRESENT
         /*DOM-IGNORE-BEGIN*/
     = ( 1 << 0 )                        /*DOM-IGNORE-END*/
       ,
       /* Indicates that the core driver receiver buffer is empty */
       DRV_USART_TRANSFER_STATUS_RECEIVER_EMPTY
         /*DOM-IGNORE-BEGIN*/
     = ( 1 << 1 )                        /*DOM-IGNORE-END*/
       ,
       /* Indicates that the core driver transmitter buffer is full */
       DRV_USART_TRANSFER_STATUS_TRANSMIT_FULL
         /*DOM-IGNORE-BEGIN*/
     = ( 1 << 2 )                        /*DOM-IGNORE-END*/
       ,
       /* Indicates that the core driver transmitter buffer is empty */
       DRV_USART_TRANSFER_STATUS_TRANSMIT_EMPTY
         /*DOM-IGNORE-BEGIN*/
     = ( 1 << 3 )                        /*DOM-IGNORE-END*/
   } DRV_USART_TRANSFER_STATUS ;
 // *****************************************************************************
 /* USART Driver Initialization Data
   Summary:
     Defines the data required to initialize or reinitialize the USART driver
   Description:
     This data type defines the data required to initialize or reinitialize the
     USART driver. If the driver is built statically, the members of this data
     structure are statically over-ridden by static override definitions in the
     system_config.h file.
   Remarks:
     None.
 */

 typedef
   struct
   {
     /* System module initialization data */
     SYS_MODULE_INIT moduleInit ;
     /* Identifies USART hardware module (PLIB-level) ID. For a static build of
        the driver, this is overridden by DRV_USART_MODULE_ID macro in the
        system_config.h header file. */
     USART_MODULE_ID usartID ;
     /* Identifies the Operation mode of the USART driver. For a static build of
        the driver, this is overridden by DRV_USART_MODE_SELECT macro in the
        system_config.h header file. */
     DRV_USART_OPERATION_MODE mode ;
     /* Data required by the operation mode of the driver. For a static build of
        the driver, this is overridden by DRV_USART_MODE_DATA macro in the
        system_config.h header file. */
     DRV_USART_OPERATION_MODE_DATA modeData ;
     /* Flags to enable specific features. Refer to the
        description of DRV_USART_INIT_FLAGS for more details. For a static build
        of the driver, this is overridden by DRV_USART_FLAGS macro in the
        system_config.h header file. */
     DRV_USART_INIT_FLAGS flags ;
     /* USART module Baud Rate Generator Clock. This typically
        the peripheral bus clock frequency. For a static build of the driver,
        this is overridden by DRV_USART_BRG_CLOCK macro in the system_config.h
        header file. */
     uint32_t brgClock ;
     /* The initial USART line control settings. For a static build of the driver
        this is overridden by the DRV_USART_LINE_CONTROL_SET macro in the
        system_config.h header file. */
     DRV_USART_LINE_CONTROL lineControl ;
     /* Baud Rate value to be used, if not using auto baud. For a static build of
        the driver, this is overridden by the DRV_USART_BAUD macro in the
        system_config.h header file. */
     uint32_t baud ;
     /* Handshaking mode. For a static build of the driver, this is overridden by
        the DRV_USART_HANDSHAKE_SET macro in the system_config.h header file. */
     DRV_USART_HANDSHAKE handshake ;
     /* Lines enabled for the USART operation. For a static build of the driver,
        this is overridden by the DRV_USART_LINES_ENABLE macro in
        the system_config.h header file.
        For PPS parts, pin selection in ports overrides this. */
     USART_OPERATION_MODE linesEnable ;
     /* Interrupt source ID for the transmitter interrupt. For a static build of
        the driver, this is overridden by the DRV_USART_TRANSMIT_INTERRUPT_SOURCE
        macro in the system_config.h header. */
     INT_SOURCE interruptTransmit ;
     /* Interrupt source ID for the receiver interrupt. For a static build of
        the driver, this is overridden by the DRV_USART_RECEIVE_INTERRUPT_SOURCE
        macro in the system_config.h header. */
     INT_SOURCE interruptReceive ;
     /* Interrupt source ID for the error Interrupt. For a static build of the
        driver, this is overridden by the DRV_USART_ERROR_INTERRUPT_SOURCE macro
        in the system_config.h header. */
     INT_SOURCE interruptError ;
     /* This is the receive buffer queue size. This is the maximum
        number of read requests that driver will queue. For a
        static build of the driver, this is overridden by the
        DRV_USART_RECEIVE_QUEUE_SIZE macro in system_config.h */
     unsigned int queueSizeReceive ;
     /* This is the transmit buffer queue size. This is the maximum
        number of write requests that driver will queue. For a
        static build of the driver, this is overridden by the
        DRV_USART_TRANSMIT_QUEUE_SIZE macro in system_config.h */
     unsigned int queueSizeTransmit ;
     /* This is the USART transmit DMA channel.
        For a static build of the driver, this is overridden by the
        DRV_USART_XMIT_DMA_CH_IDXn macro in system_config.h */
     DMA_CHANNEL dmaChannelTransmit ;
     /* This is the USART receive DMA channel.
        For a static build of the driver, this is overridden by the
        DRV_USART_RCV_DMA_CH_IDXn macro in system_config.h */
     DMA_CHANNEL dmaChannelReceive ;
     /* This is the USART transmit DMA channel interrupt.
        For a static build of the driver, this is overridden by the
        DRV_USART_XMIT_DMA_INT_SRC_IDXn macro in system_config.h */
     INT_SOURCE dmaInterruptTransmit ;
     /* This is the USART receive DMA channel interrupt.
        For a static build of the driver, this is overridden by the
        DRV_USART_RCV_DMA_INT_SRC_IDXn macro in system_config.h */
     INT_SOURCE dmaInterruptReceive ;
   } DRV_USART_INIT ;
 //DOM-IGNORE-BEGIN
 //DOM-IGNORE-END
        // #ifndef _DRV_USART_DEFINITIONS_H
 /*******************************************************************************
  End of File
 */

 #endif /*00 C:\microchip\harmony\v2_06\framework\driver\usart\drv_usart_definitions.h*/
 /*   CLOSE_FILE Include File */

 // DOM-IGNORE-BEGIN
 // DOM-IGNORE-END
 // *****************************************************************************
 // *****************************************************************************
 // Section: USART Driver Module Interface Routines
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Function:
      SYS_MODULE_OBJ DRV_USART_Initialize
      (
         const SYS_MODULE_INDEX index,
         const SYS_MODULE_INIT * const init
      )
   Summary:
     Initializes the USART instance for the specified driver index.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This routine initializes the USART driver instance for the specified driver
     index, making it ready for clients to open and use it. The initialization
     data is specified by the init parameter. The initialization may fail if the
     number of driver objects allocated are insufficient or if the specified
     driver instance is already initialized. The driver instance index is
     independent of the USART module ID. For example, driver instance 0 can be
     assigned to USART2. If the driver is built statically, then some of the
     initialization parameters are overridden by configuration macros. Refer to
     the description of the DRV_USART_INIT data structure for more details on
     which members on this data structure are overridden.
   Precondition:
     None.
   Parameters:
     index - Identifier for the instance to be initialized
     init - Pointer to a data structure containing any data necessary to
              initialize the driver.
   Returns:
     If successful, returns a valid handle to a driver instance object.
     Otherwise, returns SYS_MODULE_OBJ_INVALID.
   Example:
     <code>
     // The following code snippet shows an example USART driver initialization.
     // The driver is initialized for normal mode and a baud of 300. The
     // receive queue size is set to 2 and transmit queue size is set to 3.
     DRV_USART_INIT usartInit;
     SYS_MODULE_OBJ objectHandle;
     usartInit.baud = 300;
     usartInit.mode = DRV_USART_OPERATION_MODE_NORMAL;
     usartInit.flags = DRV_USART_INIT_FLAG_NONE;
     usartInit.usartID = USART_ID_2;
     usartInit.brgClock = 80000000;
     usartInit.handshake = DRV_USART_HANDSHAKE_NONE;
     usartInit.lineControl = DRV_USART_LINE_CONTROL_8NONE1;
     usartInit.interruptError = INT_SOURCE_USART_2_ERROR;
     usartInit.interruptReceive = INT_SOURCE_USART_2_RECEIVE;
     usartInit.queueSizeReceive = 2;
     usartInit.queueSizeTransmit = 3;
     usartInit.interruptTransmit = INT_SOURCE_USART_2_TRANSMIT;
     usartInit.moduleInit.value = SYS_MODULE_POWER_RUN_FULL;
     objectHandle = DRV_USART_Initialize(DRV_USART_INDEX_1, (SYS_MODULE_INIT*)&usartInitData);
     if (SYS_MODULE_OBJ_INVALID == objectHandle)
     {
         // Handle error
     }
     </code>
   Remarks:
     This routine must be called before any other USART routine is called.
     This routine should only be called once during system initialization
     unless DRV_USART_Deinitialize is called to deinitialize the driver
     instance. This routine will NEVER block for hardware access.
 */

 SYS_MODULE_OBJ
   DRV_USART_Initialize (
   const SYS_MODULE_INDEX index ,
   const SYS_MODULE_INIT * const init ) ;
 // *****************************************************************************
 /* Function:
     void DRV_USART_Deinitialize( SYS_MODULE_OBJ object )
   Summary:
     Deinitializes the specified instance of the USART driver module.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     Deinitializes the specified instance of the USART driver module, disabling
     its operation (and any hardware). Invalidates all the internal data.
   Precondition:
     Function DRV_USART_Initialize should have been called before calling this
     function.
   Parameters:
     object - Driver object handle, returned from the
                       DRV_USART_Initialize routine
   Returns:
     None.
   Example:
     <code>
     SYS_MODULE_OBJ object; // Returned from DRV_USART_Initialize
     SYS_STATUS status;
     DRV_USART_Deinitialize(object);
     status = DRV_USART_Status(object);
     if (SYS_MODULE_DEINITIALIZED != status)
     {
         // Check again later if you need to know
         // when the driver is deinitialized.
     }
     </code>
   Remarks:
     Once the Initialize operation has been called, the Deinitialize operation
     must be called before the Initialize operation can be called again. This
     routine will NEVER block waiting for hardware.
 */

 void
   DRV_USART_Deinitialize (
   SYS_MODULE_OBJ object ) ;
 // *****************************************************************************
 /* Function:
     SYS_STATUS DRV_USART_Status( SYS_MODULE_OBJ object )
   Summary:
     Gets the current status of the USART driver module.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This routine provides the current status of the USART driver module.
   Precondition:
     Function DRV_USART_Initialize should have been called before calling this
     function.
   Parameters:
     object - Driver object handle, returned from the
                       DRV_USART_Initialize routine
   Returns:
     SYS_STATUS_READY - Indicates that the driver is busy with a
                                 previous system level operation and cannot start
                                 another
     SYS_STATUS_DEINITIALIZED - Indicates that the driver has been
                                 deinitialized
   Example:
     <code>
     SYS_MODULE_OBJ object; // Returned from DRV_USART_Initialize
     SYS_STATUS usartStatus;
     usartStatus = DRV_USART _Status(object);
     if (SYS_STATUS_READY == usartStatus)
     {
         // This means the driver can be opened using the
         // DRV_USART_Open() function.
     }
     </code>
   Remarks:
     A driver can opened only when its status is SYS_STATUS_READY.
 */

 SYS_STATUS
   DRV_USART_Status (
   SYS_MODULE_OBJ object ) ;
 // *****************************************************************************
 /* Function:
     void DRV_USART_TasksTransmit (SYS_MODULE_OBJ object );
   Summary:
     Maintains the driver's transmit state machine and implements its ISR.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This routine is used to maintain the driver's internal transmit state
     machine and implement its transmit ISR for interrupt-driven implementations.
     In polling mode, this function should be called from the SYS_Tasks
     function. In interrupt mode, this function should be called in the transmit
     interrupt service routine of the USART that is associated with this USART
     driver hardware instance.
   Precondition:
     The DRV_USART_Initialize routine must have been called for the specified
     USART driver instance.
   Parameters:
     object - Object handle for the specified driver instance (returned from
                   DRV_USART_Initialize)
   Returns:
     None.
   Example:
     <code>
     SYS_MODULE_OBJ object; // Returned from DRV_USART_Initialize
     while (true)
     {
         DRV_USART_TasksTransmit (object);
         // Do other tasks
     }
     </code>
   Remarks:
     This routine is normally not called directly by an application. It is
     called by the system's Tasks routine (SYS_Tasks) or by the appropriate raw
     ISR.
     This routine may execute in an ISR context and will never block or access any
     resources that may cause it to block.
 */

 void
   DRV_USART_TasksTransmit (
   SYS_MODULE_OBJ object ) ;
 // *****************************************************************************
 /* Function:
     void DRV_USART_TasksReceive (SYS_MODULE_OBJ object );
   Summary:
     Maintains the driver's receive state machine and implements its ISR.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This routine is used to maintain the driver's internal receive state machine
     and implement its receive ISR for interrupt-driven implementations. In
     polling mode, this function should be called from the SYS_Tasks function.
     In interrupt mode, this function should be called in the receive interrupt
     service routine of the USART that is associated with this USART driver
     hardware instance.
   Precondition:
     The DRV_USART_Initialize routine must have been called for the specified
     USART driver instance.
   Parameters:
     object - Object handle for the specified driver instance (returned from
                   DRV_USART_Initialize)
   Returns:
     None.
   Example:
     <code>
     SYS_MODULE_OBJ object; // Returned from DRV_USART_Initialize
     while (true)
     {
         DRV_USART_TasksReceive (object);
         // Do other tasks
     }
     </code>
   Remarks:
     This routine is normally not called directly by an application. It is
     called by the system's Tasks routine (SYS_Tasks) or by the appropriate raw
     ISR.
     This routine may execute in an ISR context and will never block or access any
     resources that may cause it to block.
 */

 void
   DRV_USART_TasksReceive (
   SYS_MODULE_OBJ object ) ;
 // *****************************************************************************
 /* Function:
     void DRV_USART_TasksError (SYS_MODULE_OBJ object );
   Summary:
     Maintains the driver's error state machine and implements its ISR.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This routine is used to maintain the driver's internal error state machine
     and implement its error ISR for interrupt-driven implementations. In
     polling mode, this function should be called from the SYS_Tasks function.
     In interrupt mode, this function should be called in the error interrupt
     service routine of the USART that is associated with this USART driver
     hardware instance.
   Precondition:
     The DRV_USART_Initialize routine must have been called for the specified
     USART driver instance.
   Parameters:
     object - Object handle for the specified driver instance (returned from
                   DRV_USART_Initialize)
   Returns:
     None.
   Example:
     <code>
     SYS_MODULE_OBJ object; // Returned from DRV_USART_Initialize
     while (true)
     {
         DRV_USART_TasksError (object);
         // Do other tasks
     }
     </code>
   Remarks:
     This routine is normally not called directly by an application. It is
     called by the system's Tasks routine (SYS_Tasks) or by the appropriate raw
     ISR.
     This routine may execute in an ISR context and will never block or access any
     resources that may cause it to block.
 */

 void
   DRV_USART_TasksError (
   SYS_MODULE_OBJ object ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: USART Driver Client Routines
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Function:
     DRV_HANDLE DRV_USART_Open
     (
         const SYS_MODULE_INDEX index,
         const DRV_IO_INTENT ioIntent
     )
   Summary:
     Opens the specified USART driver instance and returns a handle to it.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This routine opens the specified USART driver instance and provides a
     handle that must be provided to all other client-level operations to
     identify the caller and the instance of the driver. The ioIntent
     parameter defines how the client interacts with this driver instance.
     The DRV_IO_INTENT_BLOCKING and DRV_IO_INTENT_NONBLOCKING ioIntent options
     additionally affect the behavior of the DRV_USART_Read and
     DRV_USART_Write functions. If the ioIntent is DRV_IO_INTENT_NONBLOCKING,
     then these function will not block even if the required amount of data could
     not be processed. If the ioIntent is DRV_IO_INTENT_BLOCKING, these functions
     will block until the required amount of data is processed. If the driver is
     configured for polling and bare-metal operation, it will not support
     DRV_IO_INTENT_BLOCKING. The driver will operation will always be
     non-blocking.
     If ioIntent is DRV_IO_INTENT_READ, the client will only be able to read from
     the driver. If ioIntent is DRV_IO_INTENT_WRITE, the client will only be able
     to write to the driver. If the ioIntent is DRV_IO_INTENT_READWRITE, the
     client will be able to do both, read and write.
     Specifying a DRV_IO_INTENT_EXCLUSIVE will cause the driver to provide
     exclusive access to this client. The driver cannot be opened by any
     other client.
   Precondition:
     Function DRV_USART_Initialize must have been called before calling this
     function.
   Parameters:
     index - Identifier for the object instance to be opened
     intent - Zero or more of the values from the enumeration
               DRV_IO_INTENT "ORed" together to indicate the intended use
               of the driver. See function description for details.
   Returns:
     If successful, the routine returns a valid open-instance handle (a number
     identifying both the caller and the module instance).
     If an error occurs, the return value is DRV_HANDLE_INVALID. Error can occur
     - if the number of client objects allocated via DRV_USART_CLIENTS_NUMBER is
       insufficient.
     - if the client is trying to open the driver but driver has been opened
       exclusively by another client.
     - if the driver hardware instance being opened is not initialized or is
       invalid.
     - if the client is trying to open the driver exclusively, but has already
       been opened in a non exclusive mode by another client.
     - if the driver is not ready to be opened, typically when the initialize
       routine has not completed execution.
   Example:
     <code>
     DRV_HANDLE handle;
     handle = DRV_USART_Open(DRV_USART_INDEX_0, DRV_IO_INTENT_EXCLUSIVE);
     if (DRV_HANDLE_INVALID == handle)
     {
         // Unable to open the driver
         // May be the driver is not initialized or the initialization
         // is not complete.
     }
     </code>
   Remarks:
     The handle returned is valid until the DRV_USART_Close routine is called.
     This routine will NEVER block waiting for hardware.If the requested intent
     flags are not supported, the routine will return DRV_HANDLE_INVALID. This
     function is thread safe in a RTOS application.
 */

 DRV_HANDLE
   DRV_USART_Open (
   const SYS_MODULE_INDEX index ,
   const DRV_IO_INTENT ioIntent ) ;
 // *****************************************************************************
 /* Function:
     void DRV_USART_Close( DRV_Handle handle )
   Summary:
     Closes an opened-instance of the USART driver.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This routine closes an opened-instance of the USART driver, invalidating the
     handle. Any buffers in the driver queue that were submitted by this client
     will be removed. After calling this routine, the handle passed in "handle"
     must not be used with any of the remaining driver routines (with one
     possible exception described in the "Remarks" section). A new handle must
     be obtained by calling DRV_USART_Open before the caller may use the driver
     again
   Precondition:
     The DRV_USART_Initialize routine must have been called for the specified
     USART driver instance.
     DRV_USART_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
   Returns:
     None.
   Example:
     <code>
     DRV_HANDLE handle; // Returned from DRV_USART_Open
     DRV_USART_Close(handle);
     // After this point, the handle cannot be used with any other function
     // except the DRV_USART_ClientStatus function, which can be used to query
     // the success status of the DRV_USART_Close function.
     while(DRV_USART_CLIENT_STATUS_CLOSED != DRV_USART_ClientStatus(handle));
     </code>
   Remarks:
     Usually there is no need for the client to verify that the Close operation
     has completed. The driver will abort any ongoing operations when this
     routine is called. However, if it requires additional time to do so in a
     non-blocking environment, it will still return from the Close operation but
     the handle is now a zombie handle. The client can only call the
     DRV_USART_ClientStatus on a zombie handle to track the completion of the
     Close operation. The DRV_USART_ClientStatus routine will return
     DRV_CLIENT_STATUS_CLOSED when the close operation has completed.
 */

 void
   DRV_USART_Close (
   const DRV_HANDLE handle ) ;
 // *****************************************************************************
 /*
   Function:
     DRV_USART_CLIENT_STATUS DRV_USART_ClientStatus( DRV_HANDLE handle )
   Summary:
     Gets the current client-specific status the USART driver.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This function gets the client-specific status of the USART driver associated
     with the given handle. This function can be used to check the status of
     client after the DRV_USART_Close() function has been called.
   Preconditions:
     The DRV_USART_Initialize function must have been called.
     DRV_USART_Open must have been called to obtain a valid opened device
     handle.
   Parameters:
     handle - Handle returned from the driver's open function.
   Returns:
     A DRV_USART_CLIENT_STATUS value describing the current status of the
     driver.
   Example:
     <code>
     DRV_HANDLE handle; // Returned from DRV_USART_Open
     DRV_USART_CLIENT_STATUS status;
     status = DRV_USART_ClientStatus(handle);
     if( DRV_USART_CLIENT_STATUS_CLOSED != status )
     {
         // The client had not closed.
     }
     </code>
   Remarks:
     This function will not block for hardware access and will immediately return
     the current status. This function is thread safe when called in a RTOS
     application.
 */

 DRV_USART_CLIENT_STATUS
   DRV_USART_ClientStatus (
   DRV_HANDLE handle ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: USART Driver Buffer Queuing Model Interface Routines
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Function:
     void DRV_USART_BufferAddWrite
     (
         const DRV_HANDLE handle,
         DRV_USART_BUFFER_HANDLE * bufferHandle,
         void * buffer,
         size_t size
     );
   Summary:
     Schedule a non-blocking driver write operation.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This function schedules a non-blocking write operation. The function returns
     with a valid buffer handle in the bufferHandle argument if the write request
     was scheduled successfully. The function adds the request to the hardware
     instance transmit queue and returns immediately. While the request is in the
     queue, the application buffer is owned by the driver and should not be
     modified. On returning, the bufferHandle parameter may be
     DRV_USART_BUFFER_HANDLE_INVALID for the following reasons:
     - if a buffer could not be allocated to the request
     - if the input buffer pointer is NULL
     - if the client opened the driver for read-only
     - if the buffer size is 0
     - if the transmit queue is full or the queue depth is insufficient
     If the requesting client registered an event callback with the driver, the
     driver will issue a DRV_USART_BUFFER_EVENT_COMPLETE event if the buffer was
     processed successfully or a DRV_USART_BUFFER_EVENT_ERROR event if the buffer
     was not processed successfully.
   Precondition:
     The DRV_USART_Initialize routine must have been called for the specified
     USART device instance and the DRV_USART_Status must have returned
     SYS_STATUS_READY.
     DRV_USART_Open must have been called to obtain a valid opened device handle.
     DRV_IO_INTENT_WRITE or DRV_IO_INTENT_READWRITE must have been specified in
     the DRV_USART_Open call.
   Parameters:
     handle - Handle of the communication channel as return by the
                    DRV_USART_Open function.
     bufferHandle - Pointer to an argument that will contain the return buffer handle.
     buffer - Data to be transmitted.
     size - Buffer size in bytes.
   Returns:
     The bufferHandle parameter will contain the return buffer handle. This will be
     DRV_USART_BUFFER_HANDLE_INVALID if the function was not successful.
   Example:
     <code>
     MY_APP_OBJ myAppObj;
     uint8_t mybuffer[MY_BUFFER_SIZE];
     DRV_USART_BUFFER_HANDLE bufferHandle;
     // myUSARTHandle is the handle returned
     // by the DRV_USART_Open function.
     // Client registers an event handler with driver
     DRV_USART_BufferEventHandlerSet(myUSARTHandle,
                     APP_USARTBufferEventHandler, (uintptr_t)&myAppObj);
     DRV_USART_BufferAddWrite(myUSARThandle, &bufferHandle,
                                         myBuffer, MY_BUFFER_SIZE);
     if(DRV_USART_BUFFER_HANDLE_INVALID == bufferHandle)
     {
         // Error handling here
     }
     // Event is received when
     // the buffer is processed.
     void APP_USARTBufferEventHandler(DRV_USART_BUFFER_EVENT event,
             DRV_USART_BUFFER_HANDLE bufferHandle, uintptr_t contextHandle)
     {
         // contextHandle points to myAppObj.
         switch(event)
         {
             case DRV_USART_BUFFER_EVENT_COMPLETE:
                 // This means the data was transferred.
                 break;
             case DRV_USART_BUFFER_EVENT_ERROR:
                 // Error handling here.
                 break;
             default:
                 break;
         }
     }
     </code>
   Remarks:
     This function is thread safe in a RTOS application. It can be called from
     within the USART Driver Buffer Event Handler that is registered by this
     client. It should not be called in the event handler associated with another
     USART driver instance. It should not otherwise be called directly in an ISR.
 */

 void
   DRV_USART_BufferAddWrite (
   const DRV_HANDLE handle ,
   DRV_USART_BUFFER_HANDLE * bufferHandle ,
   void * buffer ,
   const size_t size ) ;
 // *****************************************************************************
 /* Function:
     void DRV_USART_AddressedBufferAddWrite
     (
         const DRV_HANDLE hClient,
         DRV_USART_BUFFER_HANDLE * bufferHandle,
         uint8_t address,
         void * source,
         size_t nWords
     );
   Summary:
     Schedule a non-blocking addressed driver write operation.
     <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function schedules a non-blocking addressed write operation. The function returns
     with a valid buffer handle in the bufferHandle argument if the addressed write request
     was scheduled successfully. The function adds the request to the hardware
     instance transmit queue and returns immediately. While the request is in the
     queue, the application buffer is owned by the driver and should not be
     modified. On returning, the bufferHandle parameter may be
     DRV_USART_BUFFER_HANDLE_INVALID for the following reasons:
     - if a buffer could not be allocated to the request
     - if the input buffer pointer is NULL
     - if the client opened the driver for read-only
     - if the buffer size is 0
     - if the transmit queue is full or the queue depth is insufficient
     If the requesting client registered an event callback with the driver, the
     driver will issue a DRV_USART_BUFFER_EVENT_COMPLETE event if the buffer was
     processed successfully or a DRV_USART_BUFFER_EVENT_ERROR event if the buffer
     was not processed successfully.
   Precondition:
     The DRV_USART_Initialize routine must have been called for the specified
     USART device instance and the DRV_USART_Status must have returned
     SYS_STATUS_READY.
     DRV_USART_Open must have been called to obtain a valid opened device handle.
     DRV_IO_INTENT_WRITE or DRV_IO_INTENT_READWRITE must have been specified in
     the DRV_USART_Open call.
     The operation mode of the driver must be DRV_USART_OPERATION_MODE_ADDRESSED.
   Parameters:
     hClient - Handle of the communication channel as return by the
                    DRV_USART_Open function.
     bufferHandle - Pointer to an argument that will contain the return buffer handle.
     address - Address of the receiver client
     source - Data to be transmitted.
     size - Buffer size in 16-bit words.
   Returns:
     The bufferHandle parameter will contain the return buffer handle. This will be
     DRV_USART_BUFFER_HANDLE_INVALID if the function was not successful.
   Example:
     <code>
     MY_APP_OBJ myAppObj;
     uint16_t mybuffer[MY_BUFFER_SIZE];
     DRV_USART_BUFFER_HANDLE bufferHandle;
     uint8_t clientAddress;
     // myUSARTHandle is the handle returned
     // by the DRV_USART_Open function.
     // Client registers an event handler with driver
     clientAddress = 0x60;
     DRV_USART_BufferEventHandlerSet(myUSARTHandle,
                     APP_USARTBufferEventHandler, (uintptr_t)&myAppObj);
     DRV_USART_AddressedBufferAddWrite(myUSARThandle, &bufferHandle, clientAddress
                                         myBuffer, MY_BUFFER_SIZE);
     if(DRV_USART_BUFFER_HANDLE_INVALID == bufferHandle)
     {
         // Error handling here
     }
     // Event is received when
     // the buffer is processed.
     void APP_USARTBufferEventHandler(DRV_USART_BUFFER_EVENT event,
             DRV_USART_BUFFER_HANDLE bufferHandle, uintptr_t contextHandle)
     {
         // contextHandle points to myAppObj.
         switch(event)
         {
             case DRV_USART_BUFFER_EVENT_COMPLETE:
                 // This means the data was transferred.
                 break;
             case DRV_USART_BUFFER_EVENT_ERROR:
                 // Error handling here.
                 break;
             default:
                 break;
         }
     }
     </code>
   Remarks:
     This function is thread safe in a RTOS application. It can be called from
     within the USART Driver Buffer Event Handler that is registered by this
     client. It should not be called in the event handler associated with another
     USART driver instance. It should not otherwise be called directly in an ISR.
     The source buffer should be a 16-bit word aligned buffer.
     The 9th bit of the higher byte 16-bit buffer is used to indicate data/address.
 */

 void
   DRV_USART_AddressedBufferAddWrite (
   const DRV_HANDLE hClient ,
   DRV_USART_BUFFER_HANDLE * bufferHandle ,
   uint8_t address ,
   void * source ,
   size_t nWords ) ;
 // *****************************************************************************
 /* Function:
     void DRV_USART_BufferAddRead
     (
         const DRV_HANDLE handle,
         DRV_USART_BUFFER_HANDLE * bufferHandle,
         void * buffer,
         const size_t size
     )
   Summary:
     Schedule a non-blocking driver read operation.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This function schedules a non-blocking read operation. The function returns
     with a valid buffer handle in the bufferHandle argument if the read request
     was scheduled successfully. The function adds the request to the hardware
     instance receive queue and returns immediately. While the request is in the
     queue, the application buffer is owned by the driver and should not be
     modified. The function returns DRV_USART_BUFFER_HANDLE_INVALID in the
     bufferHandle argument:
     - if a buffer could not be allocated to the request
     - if the input buffer pointer is NULL
     - if the buffer size is 0
     - if the read queue size is full or queue depth is insufficient.
     - if the driver handle is invalid
     If the requesting client registered an event callback with the driver, the
     driver will issue a DRV_USART_BUFFER_EVENT_COMPLETE event if the buffer was
     processed successfully of DRV_USART_BUFFER_EVENT_ERROR event if the buffer
     was not processed successfully.
   Precondition:
     The DRV_USART_Initialize routine must have been called for the specified
     USART device instance and the DRV_USART_Status must have returned
     SYS_STATUS_READY.
     DRV_USART_Open must have been called to obtain a valid opened device handle.
     DRV_IO_INTENT_READ or DRV_IO_INTENT_READWRITE must have been specified in
     the DRV_USART_Open call.
   Parameters:
     handle - Handle of the communication channel as returned by the
                    DRV_USART_Open function.
     buffer - Buffer where the received data will be stored.
     size - Buffer size in bytes.
   Returns:
      The buffer handle is returned in the bufferHandle argument. This is
      DRV_USART_BUFFER_HANDLE_INVALID if the request was not successful.
   Example:
     <code>
     MY_APP_OBJ myAppObj;
     uint8_t mybuffer[MY_BUFFER_SIZE];
     DRV_USART_BUFFER_HANDLE bufferHandle;
     // myUSARTHandle is the handle returned
     // by the DRV_USART_Open function.
     // Client registers an event handler with driver
     DRV_USART_BufferEventHandlerSet(myUSARTHandle,
                     APP_USARTBufferEventHandler, (uintptr_t)&myAppObj);
     DRV_USART_BufferAddRead(myUSARThandle, &bufferHandle,
                                         myBuffer, MY_BUFFER_SIZE);
     if(DRV_USART_BUFFER_HANDLE_INVALID == bufferHandle)
     {
         // Error handling here
     }
     // Event is received when
     // the buffer is processed.
     void APP_USARTBufferEventHandler(DRV_USART_BUFFER_EVENT event,
             DRV_USART_BUFFER_HANDLE bufferHandle, uintptr_t contextHandle)
     {
         // contextHandle points to myAppObj.
         switch(event)
         {
             case DRV_USART_BUFFER_EVENT_COMPLETE:
                 // This means the data was transferred.
                 break;
             case DRV_USART_BUFFER_EVENT_ERROR:
                 // Error handling here.
                 break;
             default:
                 break;
         }
     }
     </code>
   Remarks:
     This function is thread safe in a RTOS application. It can be called from
     within the USART Driver Buffer Event Handler that is registered by the
     client. It should not be called in the event handler associated with another
     USART driver instance. It should not be called directly in an ISR.
 */

 void
   DRV_USART_BufferAddRead (
   const DRV_HANDLE handle ,
   DRV_USART_BUFFER_HANDLE * const bufferHandle ,
   void * buffer ,
   const size_t size ) ;
 // *****************************************************************************
 /* Function:
     void DRV_USART_BufferEventHandlerSet
     (
         const DRV_HANDLE handle,
         const DRV_USART_BUFFER_EVENT_HANDLER eventHandler,
         const uintptr_t context
     )
   Summary:
     Allows a client to identify a buffer event handling function for the driver
     to call back when queued buffer transfers have finished.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This function allows a client to identify a buffer event handling function
     for the driver to call back when queued buffer transfers have finished.
     When a client calls either the DRV_USART_BufferAddRead or
     DRV_USART_BufferAddWrite function, it is provided with a handle identifying
     the buffer that was added to the driver's buffer queue. The driver will
     pass this handle back to the client by calling "eventHandler" function when
     the buffer transfer has completed.
     The event handler should be set before the client performs any "buffer add"
     operations that could generate events. The event handler once set, persists
     until the client closes the driver or sets another event handler (which
     could be a "NULL" pointer to indicate no callback).
   Precondition:
     The DRV_USART_Initialize routine must have been called for the specified
     USART driver instance.
     DRV_USART_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
     eventHandler - Pointer to the event handler function.
     context - The value of parameter will be passed back to the client
                    unchanged, when the eventHandler function is called. It can
                    be used to identify any client specific data object that
                    identifies the instance of the client module (for example,
                    it may be a pointer to the client module's state structure).
   Returns:
     None.
   Example:
     <code>
     // myAppObj is an application specific state data object.
     MY_APP_OBJ myAppObj;
     uint8_t mybuffer[MY_BUFFER_SIZE];
     DRV_USART_BUFFER_HANDLE bufferHandle;
     // myUSARTHandle is the handle returned
     // by the DRV_USART_Open function.
     // Client registers an event handler with driver. This is done once
     DRV_USART_BufferEventHandlerSet( myUSARTHandle, APP_USARTBufferEventHandle,
                                      (uintptr_t)&myAppObj );
     DRV_USART_BufferAddRead(myUSARThandle, &bufferHandle
                                         myBuffer, MY_BUFFER_SIZE);
     if(DRV_USART_BUFFER_HANDLE_INVALID == bufferHandle)
     {
         // Error handling here
     }
     // Event Processing Technique. Event is received when
     // the buffer is processed.
     void APP_USARTBufferEventHandler(DRV_USART_BUFFER_EVENT event,
             DRV_USART_BUFFER_HANDLE handle, uintptr_t context)
     {
         // The context handle was set to an application specific
         // object. It is now retrievable easily in the event handler.
         MY_APP_OBJ myAppObj = (MY_APP_OBJ *) context;
         switch(event)
         {
             case DRV_USART_BUFFER_EVENT_COMPLETE:
                 // This means the data was transferred.
                 break;
             case DRV_USART_BUFFER_EVENT_ERROR:
                 // Error handling here.
                 break;
             default:
                 break;
         }
     }
     </code>
   Remarks:
     If the client does not want to be notified when the queued buffer transfer
     has completed, it does not need to register a callback. This function is
     thread safe when called in a RTOS application.
 */

 void
   DRV_USART_BufferEventHandlerSet (
   const DRV_HANDLE handle ,
   const DRV_USART_BUFFER_EVENT_HANDLER eventHandler ,
   const uintptr_t context ) ;
 // *****************************************************************************
 /* Function:
     DRV_USART_BUFFER_RESULT DRV_USART_BufferRemove( DRV_USART_BUFFER_HANDLE bufferHandle )
   Summary:
     Removes a requested buffer from the queue.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This function removes a specified buffer from the queue.
     The client can use this function to delete
         1. An unwated stalled buffer.
         2. Queued buffers on timeout.
     or in any other use case.
   Precondition:
     The DRV_USART_Initialize routine must have been called for the specified
     USART driver instance.
     DRV_USART_Open must have been called to obtain a valid opened device handle.
     Either the DRV_USART_BufferAddRead or DRV_USART_BufferAddWrite function
     must have been called and a valid buffer handle returned.
   Parameters:
     bufferhandle - Handle of the buffer to delete.
   Returns:
     DRV_USART_BUFFER_RESULT_HANDLE_INVALID - Buffer handle is invalid.
     DRV_USART_BUFFER_RESULT_HANDLE_EXPIRED - Buffer handle is expired.
     DRV_USART_BUFFER_RESULT_REMOVED_SUCCESFULLY - Buffer is removed from the
                 queue successfully.
     DRV_USART_BUFFER_RESULT_REMOVAL_FAILED - Failed to remove buffer from
                 the queue because of mutex timeout in RTOS environment.
   Example:
     <code>
     // myAppObj is an application specific object.
     MY_APP_OBJ myAppObj;
     uint8_t mybuffer[MY_BUFFER_SIZE];
     DRV_USART_BUFFER_HANDLE bufferHandle;
     // myUSARTHandle is the handle returned
     // by the DRV_USART_Open function.
     // Client registers an event handler with driver. This is done once
     DRV_USART_BufferEventHandlerSet( myUSARTHandle, APP_USARTBufferEventHandle,
                                      (uintptr_t)&myAppObj );
     bufferHandle = DRV_USART_BufferAddRead( myUSARThandle,
                                             myBuffer, MY_BUFFER_SIZE );
     if(DRV_USART_BUFFER_HANDLE_INVALID == bufferHandle)
     {
         // Error handling here
     }
     // Event Processing Technique. Event is received when
     // the buffer is processed.
     void APP_USARTBufferEventHandler( DRV_USART_BUFFER_EVENT event,
             DRV_USART_BUFFER_HANDLE bufferHandle, uintptr_t contextHandle )
     {
         switch(event)
         {
             case DRV_USART_BUFFER_EVENT_COMPLETE:
                 // This means the data was transferred.
                 break;
             case DRV_USART_BUFFER_EVENT_ERROR:
                 // Error handling here.
                 break;
             default:
                 break;
         }
     }
     // Timeout function, where remove queued buffer if it still exists.
     void APP_TimeOut(void)
     {
         DRV_USART_BUFFER_RESULT bufferResult;
         bufferResult = DRV_USART_BufferRemove(bufferHandle);
         if(DRV_USART_BUFFER_RESULT_REMOVED_SUCCESFULLY == bufferResult)
         {
             //Buffer removed succesfully from the queue
         }
         else
         {
             //Either buffer is invalid or expired.
             //Or not able to acquire mutex in RTOS mode.
         }
     }
     </code>
   Remarks:
     This function is thread safe when used in a RTOS application.
 */

 DRV_USART_BUFFER_RESULT
   DRV_USART_BufferRemove (
   DRV_USART_BUFFER_HANDLE bufferHandle ) ;
 // *****************************************************************************
 /* Function:
     size_t DRV_USART_BufferCompletedBytesGet
     (
         DRV_USART_BUFFER_HANDLE bufferHandle
     );
   Summary:
     Returns the number of bytes that have been processed for the
     specified buffer.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This function returns number of bytes that have been processed for the
     specified buffer. The client can use this function, in a case where the
     buffer has terminated due to an error, to obtain the number of bytes that
     have been processed. Or in any other use case.
     This function can be used for non-DMA buffer transfers only. It cannot be
     used when the USART driver is configured to use DMA.
   Precondition:
     The DRV_USART_Initialize routine must have been called for the specified
     USART driver instance.
     DRV_USART_Open must have been called to obtain a valid opened device handle.
     Either the DRV_USART_BufferAddRead or DRV_USART_BufferAddWrite function
     must have been called and a valid buffer handle returned.
   Parameters:
     bufferhandle - Handle for the buffer of which the processed number of bytes
                       to be obtained.
   Returns:
     Returns the number of bytes that have been processed for this buffer.
     Returns DRV_USART_BUFFER_HANDLE_INVALID for an invalid or an expired
     buffer handle.
   Example:
     <code>
     // myAppObj is an application specific object.
     MY_APP_OBJ myAppObj;
     uint8_t mybuffer[MY_BUFFER_SIZE];
     DRV_USART_BUFFER_HANDLE bufferHandle;
     // myUSARTHandle is the handle returned
     // by the DRV_USART_Open function.
     // Client registers an event handler with driver. This is done once
     DRV_USART_BufferEventHandlerSet( myUSARTHandle, APP_USARTBufferEventHandle,
                                      (uintptr_t)&myAppObj );
     bufferHandle = DRV_USART_BufferAddRead( myUSARThandle,
                                             myBuffer, MY_BUFFER_SIZE );
     if(DRV_USART_BUFFER_HANDLE_INVALID == bufferHandle)
     {
         // Error handling here
     }
     // Event Processing Technique. Event is received when
     // the buffer is processed.
     void APP_USARTBufferEventHandler( DRV_USART_BUFFER_EVENT event,
             DRV_USART_BUFFER_HANDLE bufferHandle, uintptr_t contextHandle )
     {
         // The context handle was set to an application specific
         // object. It is now retrievable easily in the event handler.
         MY_APP_OBJ myAppObj = (MY_APP_OBJ *) contextHandle;
         size_t processedBytes;
         switch(event)
         {
             case DRV_USART_BUFFER_EVENT_COMPLETE:
                 // This means the data was transferred.
                 break;
             case DRV_USART_BUFFER_EVENT_ERROR:
                 // Error handling here.
                 // We can find out how many bytes were processed in this
                 // buffer before the error occurred.
                 processedBytes = DRV_USART_BufferCompletedBytesGet(bufferHandle);
                 break;
             default:
                 break;
         }
     }
     </code>
   Remarks:
     This function is thread safe when used in a RTOS application.
 */

 size_t
   DRV_USART_BufferCompletedBytesGet (
   DRV_USART_BUFFER_HANDLE bufferHandle ) ;
 // *****************************************************************************
 /* Function:
     size_t DRV_USART_BufferProcessedSizeGet
     (
         DRV_USART_BUFFER_HANDLE bufferHandle
     );
   Summary:
     This API will be deprecated and not recommended to use.
     Use DRV_USART_BufferCompletedBytesGet to get the number of bytes
     processed for the specified buffer.
   Description:
     None.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     None.
   Example:
     None.
   Remarks:
     None.
 */

 size_t
   DRV_USART_BufferProcessedSizeGet (
   DRV_USART_BUFFER_HANDLE bufferHandle ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: USART Driver File System Model Routines
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Function:
     size_t DRV_USART_Read
     (
         const DRV_HANDLE handle,
         void * buffer,
         const size_t numbytes
     )
   Summary:
     Reads data from the USART.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This routine reads data from the USART. This function is blocking if the
     driver was opened by the client for blocking operation. This function will
     not block if the driver was opened by the client for non blocking operation.
     If the ioIntent parameter at the time of opening the driver was
     DRV_IO_INTENT_BLOCKING, this function will only return when (or will block
     until) numbytes of bytes have been received or if an error occurred. If there
     are buffers queued for receiving data, these buffers will be serviced first. The
     function will not return until the requested number of bytes have been read.
     If the ioIntent parameter at the time of opening the driver was
     DRV_IO_INTENT_NON_BLOCKING, this function will return with the number of
     bytes that were actually read. The function will not wait until numBytes of
     bytes have been read. If there are buffer queued for reading data, then the
     function will not block and will return immediately with 0 bytes read.
   Precondition:
     The DRV_USART_Initialize routine must have been called for the specified
     USART driver instance.
     DRV_USART_Open must have been called to obtain a valid opened device handle.
     DRV_IO_INTENT_READ or DRV_IO_INTENT_READWRITE must have been specified in
     the DRV_USART_Open call.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
     buffer - Buffer into which the data read from the USART instance
                    will be placed.
     numbytes - Total number of bytes that need to be read from the module
                    instance (must be equal to or less than the size of the
                    buffer)
   Returns:
     Number of bytes actually copied into the caller's buffer. Returns
     DRV_USART_READ_ERROR in case of an error.
   Example:
     <code>
     DRV_HANDLE myUSARTHandle; // Returned from DRV_USART_Open
     char myBuffer[MY_BUFFER_SIZE];
     unsigned int count;
     unsigned int total;
     total = 0;
     do
     {
         count = DRV_USART_Read(myUSARTHandle, &myBuffer[total], MY_BUFFER_SIZE - total);
         if(count == DRV_USART_READ_ERROR)
         {
            // There was an error. The DRV_USART_ErrorGet() function
            // can be called to find the exact error.
         }
         total += count;
         // Do something else...
     } while( total < MY_BUFFER_SIZE );
     </code>
   Remarks:
     This function is thread safe in a RTOS application. If the driver is
     configured for polled operation, this it will not support blocking operation
     in a bare metal (non-RTOS) application.
 */

 size_t
   DRV_USART_Read (
   const DRV_HANDLE handle ,
   void * buffer ,
   const size_t numbytes ) ;
 // *****************************************************************************
 /* Function:
     size_t DRV_USART_Write
     (
         const DRV_HANDLE handle,
         void * buffer,
         const size_t numbytes
     )
   Summary:
     Writes data to the USART.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This routine writes data to the USART. This function is blocking if the
     driver was opened by the client for blocking operation. This function will
     not block if the driver was opened by the client for non blocking operation.
     If the ioIntent parameter at the time of opening the driver was
     DRV_IO_INTENT_BLOCKING, this function will only return when (or will block
     until) numbytes of bytes have been transmitted or if an error occurred. If
     there are buffers queued for writing, the function will wait until all the
     preceding buffers are completed. Ongoing buffer transmit operations will not
     be affected.
     If the ioIntent parameter at the time of opening the driver was
     DRV_IO_INTENT_NON_BLOCKING, this function will return with the number of
     bytes that were actually accepted for transmission. The function will not
     wait until numBytes of bytes have been transmitted. If there a buffers queued
     for transmit, the function will not wait and will return immediately with 0
     bytes.
   Precondition:
     The DRV_USART_Initialize routine must have been called for the specified
     USART driver instance.
     DRV_USART_Open must have been called to obtain a valid opened device handle.
     DRV_IO_INTENT_WRITE or DRV_IO_INTENT_READWRITE must have been specified in
     the DRV_USART_Open call.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
     buffer - Buffer containing the data to written.
     numbytes - size of the buffer
   Returns:
     Number of bytes actually written to the driver. Return DRV_USART_WRITE_ERROR
     in case of an error.
   Example:
     <code>
     DRV_HANDLE myUSARTHandle; // Returned from DRV_USART_Open
     char myBuffer[MY_BUFFER_SIZE];
     int count;
     unsigned int total;
     total = 0;
     do
     {
         count = DRV_USART_Write(myUSARTHandle, &myBuffer[total],
                                                 MY_BUFFER_SIZE - total);
         total += count;
         // Do something else...
     } while( total < MY_BUFFER_SIZE );
     </code>
   Remarks:
     This function is thread safe in a RTOS application. This function is thread
     safe in a RTOS application. If the driver is configured for polled
     operation, this it will not support blocking operation in a bare metal (non-RTOS)
     application.
 */

 size_t
   DRV_USART_Write (
   const DRV_HANDLE handle ,
   void * buffer ,
   const size_t numbytes ) ;
 // *****************************************************************************
 /* Function:
     DRV_USART_TRANSFER_STATUS DRV_USART_TransferStatus( const DRV_HANDLE handle )
   Summary:
     Returns the transmitter and receiver transfer status.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This returns the transmitter and receiver transfer status.
   Precondition:
     The DRV_USART_Initialize routine must have been called for the specified
     USART driver instance.
     DRV_USART_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
   Returns:
     A DRV_USART_TRANSFER_STATUS value describing the current status
     of the transfer.
   Example:
   <code>
     DRV_HANDLE myUSARTHandle; // Returned from DRV_USART_Open
     if (DRV_USART_TRANSFER_STATUS_RECEIVER_DATA_PRESENT & DRV_USART_TransferStatus(myUSARTHandle))
     {
         // Data has been received that can be read
     }
   </code>
   Remarks:
     The returned status may contain a value with more than one of the bits
     specified in the DRV_USART_TRANSFER_STATUS enumeration set. The caller
     should perform an "AND" with the bit of interest and verify if the result is
     non-zero (as shown in the example) to verify the desired status bit. This
     function is thread safe when called in a RTOS application.
 */

 DRV_USART_TRANSFER_STATUS
   DRV_USART_TransferStatus (
   const DRV_HANDLE handle ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: USART Driver Byte Model Routines
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Function:
     uint8_t DRV_USART_ReadByte( const DRV_HANDLE handle )
   Summary:
     Reads a byte of data from the USART.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This routine reads a byte of data from the USART.
   Precondition:
     The DRV_USART_Initialize routine must have been called for the specified
     USART driver instance.
     DRV_USART_Open must have been called to obtain a valid opened device handle.
     The transfer status should be checked to see if the receiver is not empty
     before calling this function.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
   Returns:
     A data byte received by the driver.
   Example:
     <code>
     DRV_HANDLE myUSARTHandle; // Returned from DRV_USART_Open
     char myBuffer[MY_BUFFER_SIZE];
     unsigned int numBytes;
     numBytes = 0;
     do
     {
         if( DRV_USART_TRANSFER_STATUS_RECEIVER_DATA_PRESENT & DRV_USART_TransferStatus(myUSARTHandle) )
         {
             myBuffer[numBytes++] = DRV_USART_ReadByte(myUSARTHandle);
         }
         // Do something else...
     } while( numBytes < MY_BUFFER_SIZE);
     </code>
   Remarks:
     This function is thread safe when called in a RTOS application. Note that
     DRV_USART_WriteByte and DRV_USART_ReadByte function cannot co-exist with
     DRV_USART_BufferAddRead, DRV_USART_BufferAddWrite, DRV_USART_Read and
     DRV_USART_Write functions in a application. Calling the
     DRV_USART_ReadByte and DRV_USART_WriteByte functions will disrupt the
     processing of any queued buffers.
 */

 uint8_t
   DRV_USART_ReadByte (
   const DRV_HANDLE handle ) ;
 // *****************************************************************************
 /* Function:
     void DRV_USART_WriteByte( const DRV_HANDLE handle, const uint8_t byte)
   Summary:
     Writes a byte of data to the USART.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This routine writes a byte of data to the USART.
   Precondition:
     The DRV_USART_Initialize routine must have been called for the specified
     USART driver instance.
     DRV_USART_Open must have been called to obtain a valid opened device handle.
     The transfer status should be checked to see if transmitter is not full
     before calling this function.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
     byte - Data byte to write to the USART
   Returns:
     None.
   Example:
     <code>
     DRV_HANDLE myUSARTHandle; // Returned from DRV_USART_Open
     char myBuffer[MY_BUFFER_SIZE];
     unsigned int numBytes;
     // Preinitialize myBuffer with MY_BUFFER_SIZE bytes of valid data.
     numBytes = 0;
     while( numBytes < MY_BUFFER_SIZE );
     {
         if( !(DRV_USART_TRANSFER_STATUS_TRANSMIT_FULL & DRV_USART_TransferStatus(myUSARTHandle)) )
         {
             DRV_USART_WriteByte(myUSARTHandle, myBuffer[numBytes++]);
         }
         // Do something else...
     }
     </code>
   Remarks:
     This function is thread safe when called in a RTOS application. Note that
     DRV_USART_WriteByte and DRV_USART_ReadByte function cannot co-exist with
     DRV_USART_BufferAddRead, DRV_USART_BufferAddWrite, DRV_USART_Read and
     DRV_USART_Write functions in a application. Calling the
     DRV_USART_ReadByte and DRV_USART_WriteByte function will disrupt the
     processing of any queued buffers.
 */

 void
   DRV_USART_WriteByte (
   const DRV_HANDLE handle ,
   const uint8_t byte ) ;
 // *****************************************************************************
 /* Function:
      unsigned int DRV_USART_ReceiverBufferSizeGet( const DRV_HANDLE handle )
   Summary:
     Returns the size of the receive buffer.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This routine returns the size of the receive buffer.
   Precondition:
     The DRV_USART_Initialize routine must have been called for the specified
     USART driver instance.
     DRV_USART_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
   Returns:
     Size of the driver's receive buffer, in bytes.
   Example:
     <code>
     DRV_HANDLE myUSARTHandle; // Returned from DRV_USART_Open
     const uint8_t readBuffer[5];
     unsigned int size, numBytes = 0;
     unsigned int readbufferLen = sizeof(readBuffer);
     size = DRV_USART_ReceiverBufferSizeGet(myUSARTHandle);
     // Do something based on the receiver buffer size
     </code>
   Remarks:
     Does not account for client queued buffers. This function is thread safe
     when called in a RTOS application.
 */

 unsigned int
   DRV_USART_ReceiverBufferSizeGet (
   const DRV_HANDLE handle ) ;
 // *****************************************************************************
 /* Function:
     unsigned int DRV_USART_TransmitBufferSizeGet ( const DRV_HANDLE handle )
   Summary:
     Returns the size of the transmit buffer.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This routine returns the size of the transmit buffer and can be used by the
     application to determine the number of bytes to write with the
     DRV_USART_WriteByte function.
   Precondition:
     The DRV_USART_Initialize routine must have been called for the specified
     USART driver instance.
     DRV_USART_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
   Returns:
     Size of the driver's transmit buffer, in bytes.
   Examples:
     <code>
     DRV_HANDLE myUSARTHandle; // Returned from DRV_USART_Open
     const uint8_t writeBuffer[5];
     unsigned int size, numBytes = 0;
     unsigned int writeBufferLen = sizeof(writeBuffer);
     size = DRV_USART_TransmitBufferSizeGet (myUSARTHandle);
     // Do something based on the transmitter buffer size
     </code>
   Remarks:
     Does not account for client queued buffers. This function is thread safe
     when used in a RTOS application.
 */

 unsigned int
   DRV_USART_TransmitBufferSizeGet (
   const DRV_HANDLE handle ) ;
 // *****************************************************************************
 /* Function:
     bool DRV_USART_ReceiverBufferIsEmpty( const DRV_HANDLE handle )
   Summary:
     Provides the status of the driver's receive buffer.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This routine indicates if the driver's receiver buffer is empty. This
     function can be used in conjunction with the DRV_USART_Read and
     DRV_USART_ReadByte functions.
   Precondition:
     The DRV_USART_Initialize routine must have been called for the specified
     USART driver instance.
     DRV_USART_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
   Returns:
     true - if the driver's receive buffer is empty
     false - if the driver's receive buffer is not empty
   Example:
     <code>
     DRV_HANDLE myUSARTHandle; // Returned from DRV_USART_Open
     char myBuffer[MY_BUFFER_SIZE];
     unsigned int numBytes;
     numBytes = 0;
     while( numBytes < MY_BUFFER_SIZE );
     {
         if ( !DRV_USART_ReceiverBufferIsEmpty(myUSARTHandle) )
         {
             if( numBytes < MY_BUFFER_SIZE )
             {
                 myBuffer[numBytes++] = DRV_USART_ReadByte (myUSARTHandle);
             }
             else
             {
                 break;
             }
         }
         // Do something else while more data is received.
     }
     </code>
   Remarks:
     Does not account for client queued buffers. This function is safe thread
     safe when used in a RTOS application.
 */

 bool
   DRV_USART_ReceiverBufferIsEmpty (
   const DRV_HANDLE handle ) ;
 // *****************************************************************************
 /* Function:
     bool DRV_USART_TransmitBufferIsFull( const DRV_HANDLE handle )
   Summary:
     Provides the status of the driver's transmit buffer.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This routine identifies if the driver's transmit buffer is full or not. This
     function can be used in conjunction with the DRV_USART_Write and
     DRV_USART_WriteByte functions.
   Precondition:
     The DRV_USART_Initialize routine must have been called for the specified
     USART driver instance.
     DRV_USART_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
   Returns:
     true - if the transmit buffer is full
     false - if the transmit buffer is not full
   Example:
     <code>
     DRV_HANDLE myUSARTHandle; // Returned from DRV_USART_Open
     unsigned int numBytes;
     int bytesToWrite;
     const uint8_t writeBuffer[35] = "1234567890ABCDEFGHIJKLMNOP\n" ;
     int writebufferLen = strlen((char *)writeBuffer);
     numBytes = 0;
     while( numBytes < writebufferLen )
     {
         if (DRV_USART_TransmitBufferisFull())
         {
             // Do something else until there is some room in the driver's Transmit buffer.
         }
         else
         {
             DRV_USART_WriteByte(myUSARTHandle, writeBuffer[numBytes++]);
         }
     }
     </code>
   Remarks:
     Does not account for client queued buffers. This function is thread safe
     when called in a RTOS application.
 */

 bool
   DRV_USART_TransmitBufferIsFull (
   const DRV_HANDLE handle ) ;
 // *****************************************************************************
 /* Function:
     void DRV_USART_ByteTransmitCallbackSet
     (
         const SYS_MODULE_INDEX index,
         const DRV_USART_BYTE_EVENT_HANDLER eventHandler
     )
   Summary:
     Registers a callback function for byte transmit event.
   Description:
     This function allows a transmit callback function to be registered with the
     driver. The callback function is invoked when a byte has been transmitted
     using DRV_USART_WriteByte () function.
     The callback function should be registered with the driver prior to any
     writes to the driver. The callback functionality is available only in the
     interrupt mode of operation. The driver clears the interrupt after invoking
     the callback function.
   Precondition:
     The DRV_USART_Initialize routine must have been called for the specified
     USART driver instance.
   Parameters:
     index - Identifier for the object instance to be opened
     eventHandler - Pointer to the event handler function.
   Returns:
     None.
   Example:
     <code>
     // myAppObj is an application specific state data object.
     MY_APP_OBJ myAppObj;
     uint8_t mybuffer[MY_BUFFER_SIZE];
     // myUSARTHandle is the handle returned by the DRV_USART_Open function.
     myUSARTHandle = DRV_USART_Open(DRV_USART_INDEX_0, DRV_IO_INTENT_EXCLUSIVE);
                                      (uintptr_t)&myAppObj );
     // Register an event handler with driver. This is done once
     DRV_USART_ByteTransmitCallbackSet (DRV_USART_INDEX_0, APP_USARTTransmitEventHandler);
     DRV_USART_WriteByte (myUSARThandle, myBuffer[0]);
     // Event Processing Technique. Event is received when
     // the byte is transmitted.
     void APP_USARTTransmitEventHandler (const SYS_MODULE_INDEX index)
     {
         // Byte has been transmitted. Handle the event.
     }
     </code>
   Remarks:
     None
 */

 void
   DRV_USART_ByteTransmitCallbackSet (
   const SYS_MODULE_INDEX index ,
   const DRV_USART_BYTE_EVENT_HANDLER eventHandler ) ;
 // *****************************************************************************
 /* Function:
     void DRV_USART_ByteReceiveCallbackSet
     (
         const SYS_MODULE_INDEX index,
         const DRV_USART_BYTE_EVENT_HANDLER eventHandler
     )
   Summary:
     Registers receive callback function for byte receive event.
   Description:
     This function allows a receive callback function to be registered with the
     driver. The callback function is invoked when a byte has been received. The
     received byte can then be read using DRV_USART_ReadByte() function.
     The callback function should be registered with the driver as part of the
     initialization. The callback functionality is available only in the
     interrupt mode of operation. The driver clears the interrupt after invoking
     the callback function.
   Precondition:
     The DRV_USART_Initialize routine must have been called for the specified
     USART driver instance.
   Parameters:
     index - Identifier for the object instance to be opened
     eventHandler - Pointer to the event handler function.
   Returns:
     None.
   Example:
     <code>
     // myAppObj is an application specific state data object.
     MY_APP_OBJ myAppObj;
     uint8_t mybuffer[MY_BUFFER_SIZE];
     // myUSARTHandle is the handle returned by the DRV_USART_Open function.
     myUSARTHandle = DRV_USART_Open(DRV_USART_INDEX_0, DRV_IO_INTENT_EXCLUSIVE);
                                      (uintptr_t)&myAppObj );
     // Register an event handler with driver. This is done once
     DRV_USART_ByteReceiveCallbackSet(DRV_USART_INDEX_0, APP_USARTReceiveEventHandler);
     // Event Processing Technique. Event is received when
     // a byte is received.
     void APP_USARTReceiveEventHandler(const SYS_MODULE_INDEX index)
     {
         // Byte has been Received. Handle the event.
         // Read byte using DRV_USART_ReadByte ()
         // DRV_USART_ReceiverBufferIsEmpty() function can be used to
         // check if the receiver buffer is empty.
     }
     </code>
   Remarks:
     None
 */

 void
   DRV_USART_ByteReceiveCallbackSet (
   const SYS_MODULE_INDEX index ,
   const DRV_USART_BYTE_EVENT_HANDLER eventHandler ) ;
 // *****************************************************************************
 /* Function:
     void DRV_USART_ByteErrorCallbackSet
     (
         const SYS_MODULE_INDEX index,
         const DRV_USART_BYTE_EVENT_HANDLER eventHandler
     )
   Summary:
     Registers callback to handle for byte error events.
   Description:
     This function allows a callback function to be registered with the driver
     to handle the error events occurring in the transmit/receive path during
     byte transfers.
     The callback function should be registered as part of the initialization.
     The callback functionality is available only in the interrupt mode of
     operation. The driver clears the interrupt after invoking the callback
     function.
   Precondition:
     The DRV_USART_Initialize routine must have been called for the specified
     USART driver instance.
   Parameters:
     index - Identifier for the object instance to be opened
     eventHandler - Pointer to the event handler function.
   Returns:
     None.
   Example:
     <code>
     // myAppObj is an application specific state data object.
     MY_APP_OBJ myAppObj;
     uint8_t mybuffer[MY_BUFFER_SIZE];
     // myUSARTHandle is the handle returned by the DRV_USART_Open function.
     myUSARTHandle = DRV_USART_Open(DRV_USART_INDEX_0, DRV_IO_INTENT_EXCLUSIVE);
                                      (uintptr_t)&myAppObj );
     // Register an event handler with driver. This is done once
     DRV_USART_ByteErrorCallbackSet (DRV_USART_INDEX_0, APP_USARTErrorEventHandler);
     // Event Processing Technique.
     void APP_USARTErrorEventHandler(const SYS_MODULE_INDEX index)
     {
         // Error has occurred. Handle the event.
     }
     </code>
   Remarks:
     None
 */

 void
   DRV_USART_ByteErrorCallbackSet (
   const SYS_MODULE_INDEX index ,
   const DRV_USART_BYTE_EVENT_HANDLER eventHandler ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: USART Driver Setup and Status Routines
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Function:
     DRV_USART_ERROR DRV_USART_ErrorGet(DRV_HANDLE client);
   Summary:
     This function returns the error(if any) associated with the last client
     request.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This function returns the error(if any) associated with the last client
     request. DRV_USART_Read and DRV_USART_Write will update the client
     error status when these functions return DRV_USART_TRANSFER_ERROR. If the
     driver send a DRV_USART_BUFFER_EVENT_ERROR to the client, the client can
     call this function to know the error cause. The error status will be updated
     on every operation and should be read frequently (ideally immediately after
     the driver operation has completed) to know the relevant error status.
   Precondition:
     The DRV_USART_Initialize routine must have been called for the specified
     USART driver instance.
     DRV_USART_Open must have been called to obtain a valid opened device handle.
   Parameters:
     bufferhandle - Handle of the buffer of which the processed number of bytes
                       to be obtained.
   Returns:
     A DRV_USART_ERROR type indicating last known error status.
   Example:
     <code>
     // myAppObj is an application specific object.
     MY_APP_OBJ myAppObj;
     uint8_t mybuffer[MY_BUFFER_SIZE];
     DRV_USART_BUFFER_HANDLE bufferHandle;
     // myUSARTHandle is the handle returned
     // by the DRV_USART_Open function.
     // Client registers an event handler with driver. This is done once.
     DRV_USART_BufferEventHandlerSet( myUSARTHandle, APP_USARTBufferEventHandle,
                                      (uintptr_t)&myAppObj );
     bufferHandle = DRV_USART_BufferAddRead( myUSARThandle,
                                             myBuffer, MY_BUFFER_SIZE );
     if(DRV_USART_BUFFER_HANDLE_INVALID == bufferHandle)
     {
         // Error handling here
     }
     // Event Processing Technique. Event is received when
     // the buffer is processed.
     void APP_USARTBufferEventHandler( DRV_USART_BUFFER_EVENT event,
             DRV_USART_BUFFER_HANDLE bufferHandle, uintptr_t contextHandle )
     {
         // The context handle was set to an application specific
         // object. It is now retrievable easily in the event handler.
         MY_APP_OBJ myAppObj = (MY_APP_OBJ *) contextHandle;
         size_t processedBytes;
         switch(event)
         {
             case DRV_USART_BUFFER_EVENT_COMPLETE:
                 // This means the data was transferred.
                 break;
             case DRV_USART_BUFFER_EVENT_ERROR:
                 // Error handling here.
                 // We can find out how many bytes were processed in this
                 // buffer before the error occurred. We can also find
                 // the error cause.
                 processedBytes = DRV_USART_BufferCompletedBytesGet(bufferHandle);
                 if(DRV_USART_ERROR_RECEIVE_OVERRUN == DRV_USART_ErrorGet(myUSARTHandle))
                 {
                     // There was an receive over flow error.
                     // Do error handling here.
                 }
                 break;
             default:
                 break;
         }
     }
     </code>
   Remarks:
     It is the client's responsibility to make sure that the error status is
     obtained frequently. The driver will update the client error status
     regardless of whether this has been examined by the client. This function
     is thread safe when used in a RTOS application.
 */

 DRV_USART_ERROR
   DRV_USART_ErrorGet (
   const DRV_HANDLE client ) ;
 // *****************************************************************************
 /* Function:
     void DRV_USART_BaudSet(DRV_HANDLE client, uint32_t baud);
   Summary:
     This function changes the USART module baud to the specified value.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This function changes the USART module baud to the specified value. Any
     queued buffer requests will be processed at the updated baud. The USART
     driver operates at the baud specified in DRV_USART_Initialize function
     unless the DRV_USART_BaudSet function is called to change the baud.
   Precondition:
     The DRV_USART_Initialize routine must have been called for the specified
     USART driver instance.
     DRV_USART_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - client handle returned by DRV_USART_Open function.
     baud - desired baud.
   Returns:
     None.
   Example:
     <code>
     // myUSARTHandle is the handle returned
     // by the DRV_USART_Open function.
     DRV_USART_BaudSet(myUSARTHandle, 9600);
     </code>
   Remarks:
     The implementation of this function, in this release of the driver, changes
     the baud immediately. This may interrupt on-going data transfer. It is
     recommended that the driver be opened exclusively if this function is to be
     called. This function is thread safe when used in a RTOS application.
 */

 DRV_USART_BAUD_SET_RESULT
   DRV_USART_BaudSet (
   const DRV_HANDLE client ,
   uint32_t baud ) ;
 // *****************************************************************************
 /* Function:
     void DRV_USART_LineControlSet
     (
         DRV_HANDLE client,
         DRV_USART_LINE_CONTROL lineControl
     );
   Summary:
     This function changes the USART module line control to the specified value.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This function changes the USART module line control parameters to the
     specified value. Any queued buffer requests will be processed at the
     updated line control parameters. The USART driver operates at the line
     control parameters specified in DRV_USART_Initialize function unless the
     DRV_USART_LineControlSet function is called to change the line control
     parameters.
   Precondition:
     The DRV_USART_Initialize routine must have been called for the specified
     USART driver instance.
     DRV_USART_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - client handle returned by DRV_USART_Open function.
     lineControl - line control parameters.
   Returns:
     DRV_USART_LINE_CONTROL_SET_SUCCESS if the function was successful. Returns
     DRV_HANDLE_INVALID if the client handle is not valid.
   Example:
     <code>
     // myUSARTHandle is the handle returned
     // by the DRV_USART_Open function.
     DRV_USART_LineControlSet(myUSARTHandle, DRV_USART_LINE_CONTROL_8NONE1);
     </code>
   Remarks:
     The implementation of this function, in this release of the driver, changes
     the line control immediately. This may interrupt on-going data transfer. It
     is recommended that the driver be opened exclusively if this function is to
     be called. This function is thread safe when called in a RTOS application.
 */

 DRV_USART_LINE_CONTROL_SET_RESULT
   DRV_USART_LineControlSet (
   const DRV_HANDLE client ,
   const DRV_USART_LINE_CONTROL lineControl ) ;
 //DOM-IGNORE-BEGIN
 //DOM-IGNORE-END
        // #ifndef _DRV_USART_H
 /*******************************************************************************
  End of File
 */

 #endif /*00 C:\microchip\harmony\v2_06\framework\driver\usart\drv_usart.h*/
 /*   CLOSE_FILE Include File */

 /* OPEN FILE C:\microchip\harmony\v2_06\framework\driver\usart\src\drv_usart_variant_mapping.h */
 /*******************************************************************************
  USART Driver Variant Mapping
  Company:
  Microchip Technology Inc.
  File Name:
  drv_usart_variant_mapping.h
  Summary:
  USART Driver Variant Mapping
  Description:
  This file provides feature and build variant mapping macros allowing the
  driver to easily be built with different implementation variations based
  on static build-time configuration selections.
 *******************************************************************************/
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2012 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
 *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _DRV_USART_FEATURE_MAPPING_H
 #define _DRV_USART_FEATURE_MAPPING_H
 // *****************************************************************************
 // *****************************************************************************
 // Section: Interrrupt Variations
 // *****************************************************************************
 // *****************************************************************************
 /* Mapping of the interrupt mode variations
 */
  /* Driver is configured for polled mode */
 #define _DRV_USART_InterruptSourceIsEnabled( source ) false
 #define _DRV_USART_InterruptSourceEnable( source )
 #define _DRV_USART_InterruptSourceDisable( source ) false
 #define _DRV_USART_InterruptSourceStatusClear( source ) SYS_INT_SourceStatusClear ( source )
 #define _DRV_USART_SEM_POST( x ) OSAL_SEM_Post ( x )
 #define _DRV_USART_TAKE_MUTEX( x , y ) OSAL_MUTEX_Lock ( x , y )
 #define _DRV_USART_RELEASE_MUTEX( x ) OSAL_MUTEX_Unlock ( x )
 #define _SYS_DMA_ChannelForceStart( channelHandle ) SYS_DMA_ChannelForceStart ( channelHandle )
  /* This means the driver is being built in a baremetal application.
  We cannot let a client open the driver in blocking mode */
 #define _DRV_USART_ALWAYS_NON_BLOCKING ( DRV_IO_INTENT_NONBLOCKING )
 // *****************************************************************************
 // *****************************************************************************
 // Section: Buffer Queue support
 // *****************************************************************************
 // *****************************************************************************
 /* Mapping of macros for buffer queue support
 */
  /* We dont need buffer queues or byte model support */
 #define _DRV_USART_TRANSMIT_BUFFER_QUEUE_TASKS( x ) _DRV_USART_ByteTransmitTasks ( x )
 #define _DRV_USART_RECEIVE_BUFFER_QUEUE_TASKS( x ) _DRV_USART_ByteReceiveTasks ( x )
 #define _DRV_USART_ERROR_TASKS( x ) _DRV_USART_ByteErrorTasks ( x )
 #define _DRV_USART_CLIENT_BUFFER_QUEUE_OBJECTS_REMOVE( x ) true
 #define _DRV_USART_ByteModelInterruptSourceEnable( source )
 // *****************************************************************************
 // *****************************************************************************
 // Initializtion Parameter Static Overrides
 // *****************************************************************************
 // *****************************************************************************
        //_DRV_USART_FEATURE_MAPPING_H
 /*******************************************************************************
  End of File
 */
 #endif /*00 C:\microchip\harmony\v2_06\framework\driver\usart\src\drv_usart_variant_mapping.h*/
 /*   CLOSE_FILE Include File */

 #include "system/clk/sys_clk.h"
 #include "system/int/sys_int.h"
 /* OPEN FILE C:\microchip\harmony\v2_06\framework\system\debug\sys_debug.h */
 /*******************************************************************************
  Debug System Services Library Header
  Company:
  Microchip Technology Inc.

  File Name:
  sys_debug.h
  Summary:
  Defines the common debug definitions and interfaces used by MPLAB Harmony
  libraries to report errors and debug information to the user.
  Description:
  This header file defines the common debug definitions and interface macros
  (summary below) and prototypes used by MPLAB Harmony libraries to report
  errors and debug information to the user.
  *******************************************************************************/
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2013-2015 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
  *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _SYS_DEBUG_H
 #define _SYS_DEBUG_H
 #include "C:\microchip\harmony\v2_06\framework\system\system.h"
                                                                 /* LDRA full path */
 // This should be defined in system_config.h. It is added here as a build safe-guard.
 #define SYS_DEBUG_BUFFER_DMA_READY
 // *****************************************************************************
 // *****************************************************************************
 // Section: SYS DEBUG Data Types
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* SYS_ERROR_LEVEL enumeration
    Summary:
     System error message priority levels.
    Description:
     This enumeration defines the supported system error message priority values.
    Remarks:
     Used by debug message macros to compare individual message priority against
     a global system-wide error message priority level to determine if an
     individual message should be displayed.
 */

 typedef
   enum
   {
     /* Errors that have the potential to cause a system crash. */
     SYS_ERROR_FATAL = 0 ,
     /* Errors that have the potential to cause incorrect behavior. */
     SYS_ERROR_ERROR = 1 ,
     /* Warnings about potentially unexpected behavior or side effects. */
     SYS_ERROR_WARNING = 2 ,
     /* Information helpful to understanding potential errors and warnings. */
     SYS_ERROR_INFO = 3 ,
     /* Verbose information helpful during debugging and testing. */
     SYS_ERROR_DEBUG = 4
   } SYS_ERROR_LEVEL ;
 // DOM-IGNORE-BEGIN
 // *****************************************************************************
 /* Do not use this variable directly. Use SYS_DEBUG_ErrorLevelGet or
    SYS_DEBUG_ErrorLevelSet functions to access this value.
 */

 extern SYS_ERROR_LEVEL
   gblErrLvl ;
 // DOM-IGNORE-END
 // *****************************************************************************
 /* SYS Debug Module Index Number
   Summary:
     Debug System Service index.
   Description:
     This constant defines a symbolic name for the debug system service index.
   Remarks:
     There can only be a single debug system service instance in the system.
 */
 #define SYS_DEBUG_INDEX_0 0
 // *****************************************************************************
 /* SYS Debug Initialize structure
   Summary:
     Defines the data required to initialize the debug system service.
   Description:
     This structure defines the data required to initialize the debug system
     service.
   Remarks:
     None.
 */

 typedef
   struct
   {
     /* System module initialization */
     SYS_MODULE_INIT moduleInit ;
     /* Initial system error level setting. */
     SYS_ERROR_LEVEL errorLevel ;
     /* Console index to receive debug messages */
     SYS_MODULE_INDEX consoleIndex ;
   } SYS_DEBUG_INIT ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: SYS DEBUG Functions
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Function:
     SYS_MODULE_OBJ SYS_DEBUG_Initialize( const SYS_MODULE_INDEX index,
                                          const SYS_MODULE_INIT * const init )
   Summary:
     Initializes the global error level and specific module instance.
   Description:
     This function initializes the global error level. It also initializes any
     internal system debug module data structures.
   Precondition:
     None.
   Parameters:
     index - Index for the instance to be initialized
     init - Pointer to a data structure containing any data necessary
                       to initialize the debug service. This pointer may be null
                       if no data is required because static overrides have
                       been provided.
   Returns:
     If successful, returns a valid handle to an object. Otherwise, it
     returns SYS_MODULE_OBJ_INVALID.
   Example:
     <code>
     SYS_MODULE_OBJ objectHandle;
     SYS_DEBUG_INIT debugInit =
     {
         .moduleInit = {0},
         .errorLevel = SYS_ERROR_DEBUG,
     };
     objectHandle = SYS_Debug_Initialize (SYS_DEBUG_CONSOLE, (SYS_MODULE_INIT*)&debugInit);
     if (SYS_MODULE_OBJ_INVALID == objectHandle)
     {
         // Handle error
     }
     </code>
   Remarks:
     This routine should only be called once during system initialization. If the
     system was already initialized it safely returns without causing any disturbance.
 */

 SYS_MODULE_OBJ
   SYS_DEBUG_Initialize (
   const SYS_MODULE_INDEX index ,
   const SYS_MODULE_INIT * const init ) ;
 // *****************************************************************************
 /* Function:
     void SYS_DEBUG_Reinitialize( SYS_MODULE_OBJ object,
                                const SYS_MODULE_INIT * const init )
    Summary:
     Reinitializes and refreshes the data structure for the instance of the
     Debug module.
    Description:
     This function reinitializes and refreshes the data structure for the instance
     of the Debug module using the supplied data.
   Precondition:
     The SYS_DEBUG_Initialize function should have been called before calling
     this function.
   Parameters:
     object - Identifies the SYS DEBUG Object returned by the Initialize
                       interface
     init - Pointer to the data structure containing any data
                       necessary to initialize the hardware
    Returns:
     None
    Example:
     <code>
     SYS_MODULE_OBJ objectHandle;
     // Populate the console initialization structure
     SYS_DEBUG_INIT dbgInit =
     {
         .moduleInit = {0},
         .errorLevel = SYS_ERROR_DEBUG,
     };
     SYS_DEBUG_Reinitialize (objectHandle, (SYS_MODULE_INIT*)&dbgInit);
     </code>
    Remarks:
     This operation uses the same initialization data structure as the
     SYS_DEBUG_Initialize operation. This function can be called multiple times
     to reinitialize the module.
 */

 void
   SYS_DEBUG_Reinitialize (
   SYS_MODULE_OBJ object ,
   const SYS_MODULE_INIT * const init ) ;
 // *****************************************************************************
 /* Function:
     void SYS_DEBUG_Deinitialize( SYS_MODULE_OBJ object )
   Summary:
     Deinitializes the specific module instance of the Debug module.
   Description:
     This function deinitializes the specific module instance disabling its
     operation (and any hardware for driver modules). Resets all of the internal
     data structures and fields for the specified instance to the default settings.
   Precondition:
     The SYS_DEBUG_Initialize function should have been called before calling
     this function.
   Parameters:
     object - SYS DEBUG object handle, returned from SYS_DEBUG_Initialize
   Returns:
     None.
   Example:
     <code>
     SYS_MODULE_OBJ object; // Returned from SYS_DEBUG_Initialize
     SYS_DEBUG_Deinitialize (object);
     </code>
   Remarks:
     Once the Initialize operation has been called, the Deinitialize
     operation must be called before the Initialize operation can be called
     again.
 */

 void
   SYS_DEBUG_Deinitialize (
   SYS_MODULE_OBJ object ) ;
 // *****************************************************************************
 /* Function:
     void SYS_DEBUG_Tasks( SYS_MODULE_OBJ object )
   Summary:
     Maintains the debug module's state machine.
   Description:
     This function is used to maintain the debug module's internal state
     machine and implement its ISR for interrupt-driven implementations.
   Precondition:
     The SYS_DEBUG_Initialize function must have been called for the specified
     CONSOLE driver instance.
   Parameters:
     object - SYS DEBUG object handle, returned from SYS_DEBUG_Initialize
   Returns:
     None.
   Example:
     <code>
     SYS_MODULE_OBJ object; // Returned from SYS_DEBUG_Initialize
     while (true)
     {
         SYS_DEBUG_Tasks (object);
         // Do other tasks
     }
     </code>
   Remarks:
     This function is normally not called directly by an application. It is
     called by the system's Tasks routine (SYS_Tasks) or by the appropriate raw
     ISR.
 */

 void
   SYS_DEBUG_Tasks (
   SYS_MODULE_OBJ object ) ;
 // *****************************************************************************
 /* Function:
     SYS_STATUS SYS_DEBUG_Status( SYS_MODULE_OBJ object )
   Summary:
     Returns status of the specific instance of the debug service module.
   Description:
     This function returns the status of the specific debug service module
     instance.
   Precondition:
     The SYS_CONSOLE_Initialize function should have been called before calling
     this function.
   Parameters:
     object - Debug module object handle, returned from SYS_DEBUG_Initialize
   Returns:
     * SYS_STATUS_READY - Indicates that the module is running and
                                   ready to service requests. Any value greater
                                   than SYS_STATUS_READY is also a normal
                                   running state in which the module is ready
                                   to accept new operations.
     * SYS_STATUS_BUSY - Indicates that the module is busy with a
                                   previous system level operation and cannot
                                   start another.
     * SYS_STATUS_ERROR - Indicates that the module is in an error
                                   state. Any value less than SYS_STATUS_ERROR
                                   is also an error state.
     * SYS_STATUS_UNINITIALIZED - Indicates that the module has not been
                                   initialized or has been deinitialized.
   Example:
     <code>
     SYS_MODULE_OBJ object; // Returned from SYS_CONSOLE_Initialize
     SYS_STATUS debugStatus;
     debugStatus = SYS_DEBUG_Status (object);
     if (SYS_STATUS_ERROR >= debugStatus)
     {
         // Handle error
     }
     </code>
   Remarks:
     None.
 */

 SYS_STATUS
   SYS_DEBUG_Status (
   SYS_MODULE_OBJ object ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: SYS DEBUG Console Functions
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Function:
     SYS_DEBUG_Message( const char* message );
   Summary:
     Prints a message to the console regardless of the system error level.
   Description:
     This function prints a message to the console regardless of the system
     error level. It can be used as an implementation of the SYS_MESSAGE and
     SYS_DEBUG_MESSAGE macros.
   Precondition:
     SYS_DEBUG_Initialize must have returned a valid object handle and the
     SYS_DEBUG_Tasks function must be called by the system to complete the
     message request.
   Parameters:
     message - Pointer to a message string to be displayed.
   Returns:
     None.
   Example:
     <code>
     // In system_config.h:
 #define SYS_MESSAGE(message) SYS_DEBUG_Message(message)

     // In source (.c) files:
     SYS_MESSAGE("My Message\n\r");
     </code>
   Remarks:
     Do not call this function directly. Call the SYS_MESSAGE or
     SYS_DEBUG_MESSAGE macros instead.

     The default SYS_MESSAGE and SYS_DEBUG_MESSAGE macro definitions remove
     the messages and message function calls from the source code. To access
     and utilize the messages, define the SYS_DEBUG_USE_CONSOLE macro or
     override the definitions of the individual macros.
 */

 void
   SYS_DEBUG_Message (
   const char * message ) ;
 // *****************************************************************************
 /* Function:
     SYS_DEBUG_Print( const char* format, ... )
   Summary:
     Formats and prints a message with a variable number of arguments to the
     console regardless of the system error level.
   Description:
     This function formats and prints a message with a variable number of
     arguments to the console regardless of the system error level. It can be
     used to implement the SYS_PRINT and SYS_DEBUG_PRINT macros.
   Precondition:
     SYS_DEBUG_Initialize must have returned a valid object handle and the
     SYS_DEBUG_Tasks function must be called by the system to complete the
     message request.
   Parameters:
     format - Pointer to a buffer containing the format string for
                       the message to be displayed.
     ... - Zero or more optional parameters to be formated as
                       defined by the format string.
   Returns:
     None.
   Example:
     <code>
     // In system_config.h
 #define SYS_PRINT(format, ...) SYS_DEBUG_Print(format, ##__VA_ARG__)

     // In source code
     int result;

     result = SomeOperation();
     if (result > MAX_VALUE)
     {
         SYS_PRINT("Result of %d exceeds max value\r\n", result);
     }
     </code>
   Remarks:
     The format string and arguments follow the printf convention.

     Do not call this function directly. Call the SYS_PRINT or SYS_DEBUG_PRINT
     macros instead.

     The default SYS_PRINT and SYS_DEBUG_PRINT macro definitions remove the
     messages and message function calls. To access and utilize the messages,
     define the SYS_DEBUG_USE_CONSOLE macro or override the definitions of the
     individual macros.
 */

 void
   SYS_DEBUG_Print (
   const char * format ,
   ... ) ;
 // *****************************************************************************
 /* Function:
     void SYS_DEBUG_ErrorLevelSet(SYS_ERROR_LEVEL level);
   Summary:
     Sets the global system error reporting level.
   Description:
     This function sets the global system error reporting level.

   Precondition:
     SYS_DEBUG_Initialize must have returned a valid object handle.
   Parameters:
     level - The desired system error level.
   Returns:
     None.
   Example:
     <code>
     SYS_DEBUG_ErrorLevelSet(SYS_ERROR_WARNING);
     </code>
   Remarks:
     None.
 */

 void
   SYS_DEBUG_ErrorLevelSet (
   SYS_ERROR_LEVEL level ) ;
 // *****************************************************************************
 /* Function:
    SYS_ERROR_LEVEL SYS_DEBUG_ErrorLevelGet(void);
   Summary:
     Returns the global system Error reporting level.
   Description:
     This function returns the global System Error reporting level.

   Precondition:
     SYS_DEBUG_Initialize must have returned a valid object handle.
   Parameters:
     None.
   Returns:
     The global System Error Level.
   Example:
     <code>
     SYS_ERROR_LEVEL level;

     level = SYS_DEBUG_ErrorLevelGet();
     </code>
   Remarks:
     None.
 */

 SYS_ERROR_LEVEL
   SYS_DEBUG_ErrorLevelGet ( void ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: SYS DEBUG Macros
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Macro:
     _SYS_DEBUG_MESSAGE( SYS_ERROR_LEVEL level, const char* message )
   Summary:
     Prints a debug message if the specified level is at or below the global
     system error level.
   Description:
     This macro prints a debug message if the specified level is at or below the
     global error level. It can be used to implement the SYS_DEBUG_MESSAGE macro.
   Precondition:
     SYS_DEBUG_Initialize must have returned a valid object handle.
   Parameters:
     level - The current error level threshold for displaying the message.
     message - Pointer to a buffer containing the message to be displayed.
   Returns:
     None.
   Example:
     <code>
     // In system_config.h
 #define SYS_DEBUG_MESSAGE(level,message) _SYS_DEBUG_MESSAGE(level,message)

     // In library source (.c) code.
     SYS_DEBUG_MESSAGE(SYS_ERROR_WARNING, "My debug warning message\n\r");
     </code>
   Remarks:
     Do not call this macro directly. Call the SYS_DEBUG_MESSAGE macro instead.

     The default SYS_DEBUG_MESSAGE macro definition removes the message and
     function call from the source code. To access and utilize the message,
     define the SYS_DEBUG_USE_CONSOLE macro or override the definition of the
     SYS_DEBUG_MESSAGE macro.
 */
 #define _SYS_DEBUG_MESSAGE( level , message ) do { if ( ( level ) <= SYS_DEBUG_ErrorLevelGet ( ) ) SYS_DEBUG_Message ( message ) ; } while ( 0 )
 // *****************************************************************************
 /* Macro:
     _SYS_DEBUG_PRINT( SYS_ERROR_LEVEL level, const char* format, ... )
   Summary:
     Formats and prints a debug message if the specified level is at or below the
     global system error level.
   Description:
     This function formats and prints a debug message if the specified level is
     at or below the global system error level. It can be used to implement the
     SYS_DEBUG_PRINT macro.
   Precondition:
     SYS_DEBUG_Initialize must have returned a valid object handle.
   Parameters:
     level - The current error level threshold for displaying the message.
     format - Pointer to a buffer containing the format string for
                       the message to be displayed.
     ... - Zero or more optional parameters to be formated as
                       defined by the format string.
   Returns:
     None.
   Example:
     <code>
     // In system_config.h
 #define SYS_DEBUG_PRINT(level, format, ...) _SYS_DEBUG_PRINT(level, format, ##__VA_ARG__)

     // In source code
     int result;

     result = SomeOperation();
     if (result > MAX_VALUE)
     {
         SYS_DEBUG_PRINT(SYS_ERROR_WARNING, "Result of %d exceeds max value\r\n", result);
         // Take appropriate action
     }
     </code>
   Remarks:
     Do not call this macro directly. Call the SYS_DEBUG_PRINT macro instead.

     The default SYS_DEBUG_PRINT macro definition removes the message and
     function call from the source code. To access and utilize the message,
     define the SYS_DEBUG_USE_CONSOLE macro or override the definition of the
     SYS_DEBUG_PRINT macro.
 */
 #define _SYS_DEBUG_PRINT( level , format ,... ) do { if ( ( level ) <= SYS_DEBUG_ErrorLevelGet ( ) ) SYS_DEBUG_Print ( format , ## __VA_ARGS__ ) ; } while ( 0 )
 // DOM-IGNORE-BEGIN
 // *****************************************************************************
 /* These definitions support the SYS_DEBUG_USE_CONSOLE build-time configuration
     option. Defining SYS_DEBUG_USE_CONSOLE in the system configuration
     (system_config.h) will map the macros below to the appropriate system
     console functions.
 */
 // DOM-IGNORE-END
 // *****************************************************************************
 /* Macro:
     SYS_MESSAGE( const char* message )
   Summary:
     Prints a message to the console regardless of the system error level.
   Description:
     This macro is used to print a message to the console regardless of the
     system error level. It can be mapped to any desired implementation.
   Precondition:
     If mapped to the _SYS_MESSAGE function, then the system debug service must
     be initialized and running.
   Parameters:
     message - Pointer to a buffer containing the message string to be
                       displayed.
   Returns:
     None.
   Example:
     <code>
     // In system_config.h:
 #define SYS_MESSAGE(message) _SYS_MESSAGE(message)

     // In source (.c) files:
     SYS_MESSAGE("My Message\n\r");
     </code>
   Remarks:
     By default, this macro is defined as nothing, effectively removing all code
     generated by calls to it. To process SYS_MESSAGE calls, this macro must be
     defined in a way that maps calls to it to the desired implementation (see
     example, above).

     This macro can be mapped to the system console service (along with other
     system debug macros) by defining SYS_DEBUG_USE_CONSOLE in the system
     configuration (system_config.h) instead of defining it individually.
 */
 #define SYS_MESSAGE( message )
 // *****************************************************************************
 /* Function:
     SYS_DEBUG_MESSAGE( const char* message )
   Summary:
     Prints a debug message if the system error level is defined defined at
     or lower than the level specified.
   Description:
     This function prints a debug message if the system error level is defined at
     or lower than the level specified.
   Precondition:
     SYSTEM_CURRENT_ERROR_LEVEL must be defined as SYS_ERROR_DEBUG.
   Parameters:
     level - The current error level threshold for displaying the message.
     message - Pointer to a buffer containing the message to be displayed.
   Returns:
     None.
   Example:
     <code>
 #define SYS_DEBUG_MESSAGE _SYS_DEBUG_MESSAGE
     SYS_ERROR_LevelSet(SYS_ERROR_DEBUG);
     SYS_DEBUG_MESSAGE("System Debug Message \n\r");
     </code>
   Remarks:
     By default, this macro is defined as nothing, effectively removing all code
     generated by calls to it. To process SYS_DEBUG_MESSAGE calls, this macro
     must be defined in a way that maps calls to it to the desired implementation
     (see example, above).

     This macro can be mapped to the system console service (along with other
     system debug macros) by defining SYS_DEBUG_USE_CONSOLE in the system
     configuration (system_config.h) instead of defining it individually.
 */
 #define SYS_DEBUG_MESSAGE( level , message )
 // *****************************************************************************
 /* Function:
     SYS_PRINT(const char* format, ...);
   Summary:
     Formats and prints an error message with a variable number of arguments
     regardless of the system error level.
   Description:
     This function formats and prints an error message with a variable number of
     if the system error level is defined at or lower than the level specified.
   Precondition:
     SYSTEM_CURRENT_ERROR_LEVEL must be defined.
   Parameters:
     format - Pointer to a buffer containing the format string for
                       the message to be displayed.
     ... - Zero or more optional parameters to be formated as
                       defined by the format string.
   Returns:
     None.
   Example:
     <code>
     // In system_config.h
 #define SYS_PRINT(format, ...) _SYS_DEBUG_PRINT(format, ##__VA_ARG__)

     // In source code
     int result;

     result = SomeOperation();
     if (result > MAX_VALUE)
     {
         SYS_PRINT("Result of %d exceeds max value\r\n", result);
         // Take appropriate action
     }
     </code>
   Remarks:
     The format string and arguments follow the printf convention. This function
     is called by the macros SYS_PRINT and SYS_ERROR_PRINT

     By default, this macro is defined as nothing, effectively removing all code
     generated by calls to it. To process SYS_PRINT calls, this macro must be
     defined in a way that maps calls to it to the desired implementation (see
     example, above).

     This macro can be mapped to the system console service (along with other
     system debug macros) by defining SYS_DEBUG_USE_CONSOLE in the system
     configuration (system_config.h) instead of defining it individually.
 */
 #define SYS_PRINT( fmt ,... )
 // *****************************************************************************
 /* Macro:
     SYS_DEBUG_PRINT( SYS_ERROR_LEVEL level, const char* format, ... )
   Summary:
     Formats and prints an error message if the system error level is defined at
     or lower than the level specified.
   Description:
     This macro formats and prints an error message if the system error level
     is defined at or lower than the level specified.o
   Precondition:
     SYS_DEBUG_Initialize must have returned a valid object handle.
   Parameters:
     level - The current error level threshold for displaying the message.
     format - Pointer to a buffer containing the format string for
                       the message to be displayed.
     ... - Zero or more optional parameters to be formated as
                       defined by the format string.
   Returns:
     None.
   Example:
     <code>
     // In system_config.h
 #define SYS_DEBUG_PRINT(level, format, ...) _SYS_DEBUG_PRINT(level, format, ##__VA_ARG__)

     // In source code
     int result;

     result = SomeOperation();
     if (result > MAX_VALUE)
     {
         SYS_DEBUG_PRINT(SYS_ERROR_WARNING, "Result of %d exceeds max value\r\n", result);
         // Take appropriate action
     }
     </code>
   Remarks:
     The format string and arguments follow the printf convention. This function
     is called by the macros SYS_PRINT and SYS_DEBUG_PRINT.

     By default, this macro is defined as nothing, effectively removing all code
     generated by calls to it. To process SYS_MESSAGE calls, this macro must be
     defined in a way that maps calls to it to the desired implementation (see
     example, above).

     This macro can be mapped to the system console service (along with other
     system debug macros) by defining SYS_DEBUG_USE_CONSOLE in the system
     configuration (system_config.h) instead of defining it individually.
 */
 #define SYS_DEBUG_PRINT( level , fmt ,... )
 // *****************************************************************************
 /* Macro:
     SYS_DEBUG_BreakPoint( void )
   Summary:
     Inserts a software breakpoint instruction when building in Debug mode.
   Description:
     This macro inserts a software breakpoint instruction when building in Debug
     mode.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     None.
   Example:
     <code>
     if (myDebugTestFailed)
     {
         SYS_DEBUG_BreakPoint();
     }
     </code>
   Remarks:
     Compiles out if not built for debugging.
 */
 #define SYS_DEBUG_BreakPoint( )
 // *****************************************************************************
 // *****************************************************************************
 // Section: SYS DEBUG Deprecated Macros
 // *****************************************************************************
 // *****************************************************************************
 /* Do not use these macros for new development.
 */
 //DOM-IGNORE-BEGIN
 #define SYS_DEBUG( level , message ) SYS_DEBUG_MESSAGE ( level , message )
 #define SYS_ERROR( level , fmt ,... ) SYS_DEBUG_PRINT ( level , fmt , ## __VA_ARGS__ )
 #define SYS_ERROR_PRINT( level , fmt ,... ) SYS_DEBUG_PRINT ( level , fmt , ## __VA_ARGS__ )
 //DOM-IGNORE-END
        // _SYS_DEBUG_H
 /*******************************************************************************
  End of File
 */
 #endif /*00 C:\microchip\harmony\v2_06\framework\system\debug\sys_debug.h*/
 /*   CLOSE_FILE Include File */

 // DOM-IGNORE-BEGIN
 // DOM-IGNORE-END
 // *****************************************************************************
 // *****************************************************************************
 // Section: Data Type Definitions
 // *****************************************************************************
 // *****************************************************************************
 /* USART FIFO+RX(8+1) size */
 #define _DRV_USART_RX_DEPTH 9
 // *****************************************************************************
 /* USART Static Driver Instance Object
   Summary:
     Object used to keep any data required for the static USART driver.
   Description:
     This object is used to keep track of any data that must be maintained to
     manage the USART static driver.
   Remarks:
     None.
 */

 typedef
   struct
   {
     /* Client specific error */
     DRV_USART_ERROR error ;
   } DRV_USART_OBJ ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: Local functions.
 // *****************************************************************************
 // *****************************************************************************
 // DOM-IGNORE-BEGIN
 // DOM-IGNORE-END
        //#ifndef _DRV_USART_STATIC_LOCAL_H
 /*******************************************************************************
  End of File
 */

 #endif /*00 C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\system_config\default\framework\driver\usart\src\drv_usart_static_local.h*/
 /*   CLOSE_FILE Include File */

 // DOM-IGNORE-BEGIN
 // DOM-IGNORE-END
 // *********************************************************************************************
 // *********************************************************************************************
 // Section: System Interface Headers for the Instance 0 of USART static driver
 // *********************************************************************************************
 // *********************************************************************************************

 SYS_MODULE_OBJ
   DRV_USART0_Initialize ( void ) ;

 void
   DRV_USART0_Deinitialize ( void ) ;

 SYS_STATUS
   DRV_USART0_Status ( void ) ;

 void
   DRV_USART0_TasksTransmit ( void ) ;

 void
   DRV_USART0_TasksReceive ( void ) ;

 void
   DRV_USART0_TasksError ( void ) ;
 // *********************************************************************************************
 // *********************************************************************************************
 // Section: General Client Interface Headers for the Instance 0 of USART static driver
 // *********************************************************************************************
 // *********************************************************************************************

 DRV_HANDLE
   DRV_USART0_Open (
   const SYS_MODULE_INDEX index ,
   const DRV_IO_INTENT ioIntent ) ;

 void
   DRV_USART0_Close ( void ) ;

 DRV_USART_CLIENT_STATUS
   DRV_USART0_ClientStatus ( void ) ;

 DRV_USART_TRANSFER_STATUS
   DRV_USART0_TransferStatus ( void ) ;

 DRV_USART_ERROR
   DRV_USART0_ErrorGet ( void ) ;
 // *********************************************************************************************
 // *********************************************************************************************
 // Section: Byte Model Client Interface Headers for the Instance 0 of USART static driver
 // *********************************************************************************************
 // *********************************************************************************************

 uint8_t
   DRV_USART0_ReadByte ( void ) ;

 void
   DRV_USART0_WriteByte (
   const uint8_t byte ) ;

 unsigned int
   DRV_USART0_ReceiverBufferSizeGet ( void ) ;

 unsigned int
   DRV_USART0_TransmitBufferSizeGet ( void ) ;

 bool
   DRV_USART0_ReceiverBufferIsEmpty ( void ) ;

 bool
   DRV_USART0_TransmitBufferIsFull ( void ) ;
 // *********************************************************************************************
 // *********************************************************************************************
 // Section: Set up Client Interface Headers for the Instance 0 of USART static driver
 // *********************************************************************************************
 // *********************************************************************************************

 DRV_USART_BAUD_SET_RESULT
   DRV_USART0_BaudSet (
   uint32_t baud ) ;

 DRV_USART_LINE_CONTROL_SET_RESULT
   DRV_USART0_LineControlSet (
   DRV_USART_LINE_CONTROL lineControlMode ) ;
 // DOM-IGNORE-BEGIN
 // DOM-IGNORE-END
        // #ifndef _DRV_USART_STATIC_H
 /*******************************************************************************
  End of File
 */

 #endif /*00 C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\system_config\default\framework\driver\usart\drv_usart_static.h*/
 /*   CLOSE_FILE Include File */

 /* OPEN FILE C:\microchip\harmony\v2_06\framework\system\ports\sys_ports.h */
 /*******************************************************************************
  Ports System Service Interface Definition
  Company:
  Microchip Technology Inc.
  File Name:
  sys_ports.h
  Summary:
  Ports System Service interface definitions
  Description:
  This file contains the interface definition for the Ports system
  service. It provides a way to interact with the Ports subsystem to
  manage the timing requests supported by the system
 *******************************************************************************/
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2013-2015 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
 *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _SYS_PORTS_H
 #define _SYS_PORTS_H
 // *****************************************************************************
 // *****************************************************************************
 // Section: Included Files
 // *****************************************************************************
 // *****************************************************************************
 /* OPEN FILE C:\microchip\harmony\v2_06\framework\system\ports\sys_ports_definitions.h */
 /*******************************************************************************
  PORTS System Service Library Interface Definition
  Company:
  Microchip Technology Inc.
  File Name:
  sys_ports_definitions.h
  Summary:
  PORTS System Service data type definitions header.
  Description:
  This file contains data type definitions header.
 *******************************************************************************/
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2013-2015 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
 *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _SYS_PORTS_DEFINITIONS_H
 #define _SYS_PORTS_DEFINITIONS_H
 // *****************************************************************************
 // *****************************************************************************
 // Section: File includes
 // *****************************************************************************
 // *****************************************************************************
 #include "C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\system_config\default\system_config.h"  /* LDRA full path */
 #include "system/common/sys_common.h"
 #include "system/common/sys_module.h"
 /* OPEN FILE C:\microchip\harmony\v2_06\framework\peripheral\ports\plib_ports.h */
 /*******************************************************************************
  Ports Peripheral Library Interface Header
  Company:
  Microchip Technology Inc.
  File Name:
  plib_ports.h
  Summary:
  Ports Peripheral Library Interface header for Ports function definitions.
  Description:
  This header file contains the function prototypes and definitions of
  the data types and constants that make up the interface to the Ports
  Peripheral Library for all families of Microchip microcontrollers. The
  definitions in this file are common to the Ports peripheral.
 *******************************************************************************/
 // DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright 2013-2015 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
 *******************************************************************************/
 // DOM-IGNORE-END
 #ifndef _PLIB_PORTS_H
 #define _PLIB_PORTS_H
 #include <stdint.h>
 #include <stddef.h>
 // DOM-IGNORE-BEGIN
 // DOM-IGNORE-END
 // *****************************************************************************
 // *****************************************************************************
 // Section: Constants & Data Types
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Ports data mask definition
   Summary:
     Data type defining the Ports data mask
   Description:
     This data type defines the Ports data mask
   Remarks:
     None.
 */

 typedef
 uint16_t
   PORTS_DATA_MASK ;
 // *****************************************************************************
 /* Ports data type definition
   Summary:
     Data type defining the Ports data type.
   Description:
     This data type defines the Ports data type.
   Remarks:
     None.
 */

 typedef
 uint32_t
   PORTS_DATA_TYPE ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: Included Files (continued at end of file)
 // *****************************************************************************
 // *****************************************************************************
 /* This section lists the other files that are included in this file. However,
     please see the end of the file for additional implementation header files
     that are also included.
 */
 /* OPEN FILE C:\microchip\harmony\v2_06\framework\peripheral\ports\processor\ports_processor.h */
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2011-2016 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED 'AS IS' WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
  *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _PLIB_PORTS_PROCESSOR_H
 #define _PLIB_PORTS_PROCESSOR_H
 #error "Can't find header"
 #endif /*00 C:\microchip\harmony\v2_06\framework\peripheral\ports\processor\ports_processor.h*/
 /*   CLOSE_FILE Include File */

 // *****************************************************************************
 // *****************************************************************************
 // Section: Ports Peripheral Library Interface Routines
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_RemapInput( PORTS_MODULE_ID index,
                 PORTS_REMAP_INPUT_FUNCTION inputFunction,
                 PORTS_REMAP_INPUT_PIN remapInputPin );
   Summary:
     Input function remapping.
   Description:
     This function controls the Input function remapping. It allows user to map
     any of the input functionality on any of the remappable input pin.
     This function does not perform atomic register access.
   Precondition:
     IOLOCK bit of configuration register should be clear to allow any remapping.
     PLIB_DEVCON_DeviceRegistersUnlock function can be used for that purpose.
     Refer DEVCON PLIB (or System Service) and the specific device data sheet to
     find more information.
   Parameters:
     index - Identifier for the device instance to be configured
     inputFunction - One of the possible values of PORTS_REMAP_INPUT_FUNCTION
     remapInputPin - One of the possible values of PORTS_REMAP_INPUT_PIN
   Returns:
     None.
   Example:
     <code>

     // System Unlock
     PLIB_DEVCON_SystemUnlock(DEVCON_ID_0);
     // Unlock PPS registers
     PLIB_DEVCON_DeviceRegistersUnlock(DEVCON_ID_0, DEVCON_PPS_REGISTERS);
     // Remapping input function 'Input Capture 1' to the Remappable pin 'RPD2'
     PLIB_PORTS_RemapInput(PORTS_ID_0, INPUT_FUNC_IC1, INPUT_PIN_RPD2 );
     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsRemapInputOutput in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_RemapInput (
   PORTS_MODULE_ID index ,
   PORTS_REMAP_INPUT_FUNCTION inputFunction ,
   PORTS_REMAP_INPUT_PIN remapInputPin ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_RemapOutput( PORTS_MODULE_ID index,
                                   PORTS_REMAP_OUTPUT_FUNCTION outputFunction,
                                   PORTS_REMAP_OUTPUT_PIN remapOutputPin );
   Summary:
     Output function remapping.
   Description:
     This function controls the Output function remapping. it allows user to map
     any of the output functionality on any of the remappable output pin.
     This function does not perform atomic register access.
   Precondition:
     IOLOCK bit of configuration register should be clear to allow any remapping.
     PLIB_DEVCON_DeviceRegistersUnlock function can be used for that purpose.
     Refer DEVCON PLIB (or System Service) and the specific device data sheet to
     find more information.
   Parameters:
     index - Identifier for the device instance to be configured
     outputFunction - One of the possible values of PORTS_REMAP_OUTPUT_FUNCTION
     remapOutputPin - One of the possible values of PORTS_REMAP_OUTPUT_PIN
   Returns:
     None.
   Example:
     <code>

     // System Unlock
     PLIB_DEVCON_SystemUnlock(DEVCON_ID_0);
     // Unlock PPS registers
     PLIB_DEVCON_DeviceRegistersUnlock(DEVCON_ID_0, DEVCON_PPS_REGISTERS);
     // Remapping output function 'UART3 Transmit' to the Remappable pin 'RPA14'
     PLIB_PORTS_RemapOutput(PORTS_ID_0, OUTPUT_FUNC_U3TX, OUTPUT_PIN_RPA14);

     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsRemapInputOutput in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_RemapOutput (
   PORTS_MODULE_ID index ,
   PORTS_REMAP_OUTPUT_FUNCTION outputFunction ,
   PORTS_REMAP_OUTPUT_PIN remapOutputPin ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_PinModeSelect( PORTS_MODULE_ID index,
                                PORTS_ANALOG_PIN pin,
                                PORTS_PIN_MODE mode );
   Summary:
     Enables the selected pin as analog or digital.
   Description:
     This function enables the selected pin as analog or digital.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     pin - Possible values of PORTS_ANALOG_PIN
     mode - Possible values of PORTS_PIN_MODE
   Returns:
     None.
   Example:
     <code>

     // Make AN0 pin as Analog
     PLIB_PORTS_PinModeSelect(PORTS_ID_0, PORTS_ANALOG_PIN_0, PORTS_PIN_MODE_ANALOG);

     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPinMode in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_PinModeSelect (
   PORTS_MODULE_ID index ,
   PORTS_ANALOG_PIN pin ,
   PORTS_PIN_MODE mode ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_PinModePerPortSelect( PORTS_MODULE_ID index,
                                        PORTS_CHANNEL channel, PORTS_BIT_POS bitPos,
                                PORTS_PIN_MODE mode );
   Summary:
     Enables the selected port pin as analog or digital.
   Description:
     This function enables the selected port pin as analog or digital.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
     bitPos - Position in the PORT pins
     mode - Possible values of PORTS_PIN_MODE
   Returns:
     None.
   Example:
     <code>

     // Make RC5 pin Analog
     PLIB_PORTS_PinModePerPortSelect(PORTS_ID_0, PORT_CHANNEL_C,
                                   PORTS_BIT_POS_5, PORTS_PIN_MODE_ANALOG);

     </code>
   Remarks:
     This function is only available in devices with PPS. For Non-PPS devices, use the
     PLIB_PORTS_PinModeSelect function.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPinModePerPort in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_PinModePerPortSelect (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ,
   PORTS_PIN_MODE mode ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_ChangeNoticePullDownPerPortEnable( PORTS_MODULE_ID index,
                                PORTS_CHANNEL channel, PORTS_BIT_POS bitPos )
   Summary:
     Enables the pull-down for selected Change Notice pins.
   Description:
     This function enables the pull-down for selected Change Notice pins.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
     bitPos - Position in the PORT pins
   Returns:
     None.
   Example:
     <code>

     // Enable pull-down for RC5 pin
     PLIB_PORTS_ChangeNoticePullDownPerPortEnable(PORTS_ID_0, PORT_CHANNEL_C,
                                                                 PORTS_BIT_POS_5);

     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticePullDownPerPort in your application to
     determine whether this feature is available.
 */

 void
   PLIB_PORTS_ChangeNoticePullDownPerPortEnable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_ChangeNoticePullDownPerPortDisable( PORTS_MODULE_ID index,
                                PORTS_CHANNEL channel, PORTS_BIT_POS bitPos )
   Summary:
     Disables the pull-down for selected Change Notice pins.
   Description:
     This function disables the pull-down for selected Change Notice pins.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
     bitPos - Position in the PORT pins
   Returns:
     None.
   Example:
     <code>

     // Disable pull-down for RC5 pin
     PLIB_PORTS_ChangeNoticePullDownPerPortDisable(PORTS_ID_0, PORT_CHANNEL_C,
                                                                 PORTS_BIT_POS_5);
     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticePullDownPerPort in your application to
     determine whether this feature is available.
 */

 void
   PLIB_PORTS_ChangeNoticePullDownPerPortDisable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_ChangeNoticePullUpPerPortEnable ( PORTS_MODULE_ID index,
                                PORTS_CHANNEL channel, PORTS_BIT_POS bitPos )
   Summary:
     Enables the pull-up for selected Change Notice pins.
   Description:
     This function enables the pull-up for selected Change Notice pins.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
     bitPos - Position in the PORT pins
   Returns:
     None.
   Example:
     <code>

     // Enable pull-up for RC5 pin
     PLIB_PORTS_ChangeNoticePullUpPerPortEnable(PORTS_ID_0, PORT_CHANNEL_C,
                                                                 PORTS_BIT_POS_5);
     </code>
   Remarks:
     This function is only available in devices with PPS. For Non-PPS devices, use the
     PLIB_PORTS_ChangeNoticePullUpEnable function.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticePullUpPerPort in your application to
     determine whether this feature is available.
 */

 void
   PLIB_PORTS_ChangeNoticePullUpPerPortEnable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_ChangeNoticePullUpPerPortDisable( PORTS_MODULE_ID index,
                                PORTS_CHANNEL channel, PORTS_BIT_POS bitPos );
   Summary:
     Disables weak pull-up for the selected pin.
   Description:
     This function disables weak pull-up for the selected port pin.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
     bitPos - Position in the PORT pins
   Returns:
     None.
   Example:
     <code>

     // Disable pull-up for RC5 pin
     PLIB_PORTS_ChangeNoticePullUpPerPortDisable(PORTS_ID_0, PORT_CHANNEL_C,
                                                                 PORTS_BIT_POS_5);

     </code>
   Remarks:
     This function is only available in devices with PPS. For Non-PPS devices, use the
     PLIB_PORTS_ChangeNoticePullUpDisable function.

     Pull-ups on change notification pins should always be disabled when the
     port pin is configured as a digital output.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticePullUpPerPort in your application to
     determine whether this feature is available.
 */

 void
   PLIB_PORTS_ChangeNoticePullUpPerPortDisable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_PinChangeNoticePerPortEnable ( PORTS_MODULE_ID index,
                                PORTS_CHANNEL channel, PORTS_BIT_POS bitPos )
   Summary:
     Enables CN interrupt for the selected pin.
   Description:
     This function enables Change Notice interrupt for the selected port pin.
     This function does not perform atomic register access.

   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
     bitPos - Position in the PORT pins
   Returns:
     None.
   Example:
     <code>

     // Enable CN interrupt for RC5 pin
     PLIB_PORTS_PinChangeNoticePerPortEnable(PORTS_ID_0, PORT_CHANNEL_C,
                                                                 PORTS_BIT_POS_5);

     </code>
   Remarks:
     This function is only available in devices with PPS. For Non-PPS devices, use the
     PLIB_PORTS_PinChangeNoticeEnable function.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticeIntPerPort in your application to
     determine whether this feature is available.
 */

 void
   PLIB_PORTS_PinChangeNoticePerPortEnable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
         void PLIB_PORTS_PinChangeNoticePerPortDisable( PORTS_MODULE_ID index,
                                PORTS_CHANNEL channel, PORTS_BIT_POS bitPos )
   Summary:
     Disables CN interrupt for the selected pin.
   Description:
     This function disables Change Notice interrupt for the selected port pin.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
     bitPos - Position in the PORT pins
   Returns:
     None.
   Example:
     <code>

     // Disable CN interrupt for RC5 pin
     PLIB_PORTS_PinChangeNoticePerPortDisable(PORTS_ID_0, PORT_CHANNEL_C,
                                                                 PORTS_BIT_POS_5);

     </code>
   Remarks:
     This function is only available in devices with PPS. For Non-PPS devices, use the
     PLIB_PORTS_PinChangeNoticeDisable function.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticeIntPerPort in your application to
     determine whether this feature is available.
 */

 void
   PLIB_PORTS_PinChangeNoticePerPortDisable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_ChangeNoticePerPortTurnOn ( PORTS_MODULE_ID index,
                                PORTS_CHANNEL channel );
   Summary:
     Enables the change notification for selected port.
   Description:
     This function enables the change notification for selected port.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
   Returns:
     None.
   Example:
     <code>
     // Enable Change notification for Port C
     PLIB_PORTS_ChangeNoticePerPortTurnOn(PORTS_ID_0, PORT_CHANNEL_C);

     </code>
   Remarks:
     This function is only available in devices with PPS. For Non-PPS devices, use the
     PLIB_PORTS_ChangeNoticeEnable function.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticePerPortTurnOn in your application to determine
     whether this feature is available.
 */

 void
   PLIB_PORTS_ChangeNoticePerPortTurnOn (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_ChangeNoticePerPortTurnOff( PORTS_MODULE_ID index,
                                                         PORTS_CHANNEL channel );
   Summary:
     Disables the change notification for selected port.
   Description:
     This function disables the change notification for selected port.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
   Returns:
     None.
   Example:
     <code>
     // Disable Change notification for Port C
     PLIB_PORTS_ChangeNoticePerPortTurnOff(PORTS_ID_0, PORT_CHANNEL_C);

     </code>
   Remarks:
     This function is only available in devices with PPS. For Non-PPS devices, use the
     PLIB_PORTS_ChangeNoticeDisable function.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticePerPortTurnOn in your application to determine
     whether this feature is available.
 */

 void
   PLIB_PORTS_ChangeNoticePerPortTurnOff (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ) ;
 // *****************************************************************************
 /* Function:
         void PLIB_PORTS_ChangeNoticeInIdlePerPortEnable ( PORTS_MODULE_ID index,
                                                         PORTS_CHANNEL channel );
   Summary:
     Allows CN to be working in Idle mode for selected channel.
   Description:
     This function makes sure that change notification feature keeps working in
     Idle mode for the selected channel.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
   Returns:
     None.
   Example:
     <code>

     // Change notification continues working in Idle mode for Port C
     PLIB_PORTS_ChangeNoticeInIdlePerPortEnable(PORTS_ID_0, PORT_CHANNEL_C);

     </code>
   Remarks:
     This function is only available in devices with PPS. For Non-PPS devices, use the
     PLIB_PORTS_ChangeNoticeInIdleEnable function.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticePerPortInIdle in your application to determine
     whether this feature is available.
 */

 void
   PLIB_PORTS_ChangeNoticeInIdlePerPortEnable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_ChangeNoticeInIdlePerPortDisable( PORTS_MODULE_ID index,
                                                         PORTS_CHANNEL channel );
   Summary:
     Change Notification halts in Idle mode for selected channel.
   Description:
     This function makes sure that change notification feature halts in
     Idle mode for the selected channel.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
   Returns:
     None.
   Example:
     <code>

     // Change notification halts in Idle mode for Port C
     PLIB_PORTS_ChangeNoticeInIdlePerPortDisable(PORTS_ID_0, PORT_CHANNEL_C);

     </code>
   Remarks:
     This function is only available in devices with PPS. For Non-PPS devices, use the
     PLIB_PORTS_ChangeNoticeInIdleDisable function.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticePerPortInIdle in your application to determine
     whether this feature is available.
 */

 void
   PLIB_PORTS_ChangeNoticeInIdlePerPortDisable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ) ;
 // *****************************************************************************
 /* Function:
    bool PLIB_PORTS_ChangeNoticePerPortHasOccurred ( PORTS_MODULE_ID index,
                                PORTS_CHANNEL channel, PORTS_BIT_POS bitPos );
   Summary:
     checks the status of change on the pin
   Description:
     This function checks if the change has occurred on the given pin or not.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
     bitPos - Position in the PORT pins
   Returns:
     None.
   Example:
     <code>

     if(PLIB_PORTS_ChangeNoticePerPortHasOccurred( PORTS_ID_0,
                                     PORT_CHANNEL_C, PORTS_BIT_POS_4 ) == True)
     {
      //do something
     }

     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticePerPortStatus in your application to determine
     whether this feature is available.
 */

 bool
   PLIB_PORTS_ChangeNoticePerPortHasOccurred (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     bool PLIB_PORTS_PinGet( PORTS_MODULE_ID index, PORTS_CHANNEL channel,
                             PORTS_BIT_POS bitPos )
   Summary:
     Reads/Gets data from the selected digital pin.
   Description:
     This function reads/gets data from the selected digital PORT i/o pin.
     This function should be used to read the live data at the pin.
     This function does not perform atomic register access.

   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the Ports channel A, B, C, etc.
     bitPos - Possible values of PORTS_BIT_POS
   Returns:
     Port pin read data.
   Example:
     <code>
     // read port pin RC4
     bool bitStatus = PLIB_PORTS_PinGet(PORTS_ID_0, PORT_CHANNEL_C,
                                                         PORTS_BIT_POS_4);
     </code>
   Remarks:
     For reading the Latched data, PLIB_PORTS_PinGetLatched function should be used.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPortsRead in your application to determine whether
         this feature is available.
 */

 bool
   PLIB_PORTS_PinGet (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     bool PLIB_PORTS_PinGetLatched( PORTS_MODULE_ID index, PORTS_CHANNEL channel,
                             PORTS_BIT_POS bitPos )
   Summary:
     Reads/Gets data from the selected latch.
   Description:
     This function reads/gets data from the selected PORTx Data Latch, not from
     the port I/O pins.
     This function does not perform atomic register access.

   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the Ports channel A, B, C, etc.
     bitPos - Possible values of PORTS_BIT_POS
   Returns:
     Latch read data.
   Example:
     <code>
     // read latch RC4
     bool bitStatus = PLIB_PORTS_PinGetLatched(PORTS_ID_0, PORT_CHANNEL_C,
                                                         PORTS_BIT_POS_4);
     </code>
   Remarks:
     For reading the Live data from the i/o pin, PLIB_PORTS_PinGet function
     should be used.

     This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsLatchRead in your application to determine whether
         this feature is available.
 */

 bool
   PLIB_PORTS_PinGetLatched (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_PinWrite( PORTS_MODULE_ID index, PORTS_CHANNEL channel,
                               PORTS_BIT_POS bitPos,
                               bool value )
   Summary:
     Writes the selected digital pin/latch.
   Description:
     This function writes to the selected digital pin/latch.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the Ports channel A, B, C, etc.
     bitPos - Possible values of PORTS_BIT_POS
     value - Value to be written to the specific pin/latch
                       true - sets the bit, false - clears the bit
   Returns:
     None.
   Example:
     <code>

     // write 'one' in port RC4
     PLIB_PORTS_PinWrite(PORTS_ID_0, PORT_CHANNEL_C, PORTS_BIT_POS_4, 1);

     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPortsWrite in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_PinWrite (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ,
   bool value ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_PinSet( PORTS_MODULE_ID index, PORTS_CHANNEL channel,
                             PORTS_BIT_POS bitPos )
   Summary:
     Sets the selected digital pin/latch.
   Description:
     This function sets the selected digital pin/latch.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the Ports channel A, B, C, etc.
     bitPos - Possible values of PORTS_BIT_POS
   Returns:
     None.
   Example:
     <code>

     // Sets port pin RC4
     PLIB_PORTS_PinSet(PORTS_ID_0, PORT_CHANNEL_C, PORTS_BIT_POS_4);

     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPortsWrite in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_PinSet (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_PinClear( PORTS_MODULE_ID index, PORTS_CHANNEL channel,
                               PORTS_BIT_POS bitPos )
   Summary:
     Clears the selected digital pin/latch.
   Description:
     This function clears the selected digital pin/latch.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the Ports channel A, B, C, etc.
     bitPos - Possible values of PORTS_BIT_POS
   Returns:
     None.
   Example:
     <code>

     // Clears port pin RC4
     PLIB_PORTS_PinClear(PORTS_ID_0, PORT_CHANNEL_C, PORTS_BIT_POS_4);

     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPortsWrite in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_PinClear (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_PinToggle( PORTS_MODULE_ID index, PORTS_CHANNEL channel,
                                PORTS_BIT_POS bitPos )
   Summary:
     Toggles the selected digital pin/latch.
   Description:
     This function toggles the selected digital pin/latch.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the Ports channel A, B, C, etc.
     bitPos - Possible values of PORTS_BIT_POS
   Returns:
     None.
   Example:
     <code>

     // Toggles port pin RC4
     PLIB_PORTS_PinToggle(PORTS_ID_0, PORT_CHANNEL_C, PORTS_BIT_POS_4);

     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPortsWrite in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_PinToggle (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_PinDirectionInputSet( PORTS_MODULE_ID index, PORTS_CHANNEL channel,
                                           PORTS_BIT_POS bitPos )
   Summary:
     Makes the selected pin direction input
   Description:
     This function makes the selected pin direction as input
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the Ports channel A, B, C, etc.
     bitPos - Possible values of PORTS_BIT_POS direction that has to
                       be made input
   Returns:
     None.
   Example:
     <code>

     // make pin RC4 as input
     PLIB_PORTS_PinDirectionInputSet(PORTS_ID_0, PORT_CHANNEL_C, PORTS_BIT_POS_4);

     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPortsDirection in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_PinDirectionInputSet (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_PinDirectionOutputSet( PORTS_MODULE_ID index, PORTS_CHANNEL channel,
                                            PORTS_BIT_POS bitPos )
   Summary:
     Makes the selected pin direction output
   Description:
     This function makes the selected pin direction as output
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the Ports channel A, B, C, etc.
     bitPos - Possible values of PORTS_BIT_POS direction that has to
                       be made output
   Returns:
     None.
   Example:
     <code>

     // make pin RC4 as output
     PLIB_PORTS_PinDirectionOutputSet(PORTS_ID_0, PORT_CHANNEL_C, PORTS_BIT_POS_4);

     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPortsDirection in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_PinDirectionOutputSet (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_PinOpenDrainEnable( PORTS_MODULE_ID index, PORTS_CHANNEL channel,
                                         PORTS_BIT_POS bitPos )
   Summary:
     Enables the open drain functionality for the selected pin.
   Description:
     This function enables the open drain functionality for the selected pin.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the Ports channel A, B, C, etc.
     bitPos - Possible values of PORTS_BIT_POS
   Returns:
     None.
   Example:
     <code>

     // Enable open drain for pin RC4
     PLIB_PORTS_PinOpenDrainEnable(PORTS_ID_0, PORT_CHANNEL_C, PORTS_BIT_POS_4);

     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPortsOpenDrain in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_PinOpenDrainEnable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_PinOpenDrainDisable( PORTS_MODULE_ID index, PORTS_CHANNEL channel,
                                          PORTS_BIT_POS bitPos )
   Summary:
     Disables the open drain functionality for the selected pin.
   Description:
     This function disables the open drain functionality for the selected pin.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the Ports channel A, B, C, etc.
     bitPos - One of the possible values of PORTS_BIT_POS.
   Returns:
     None.
   Example:
     <code>

     // Disable open drain for pin RC4
     PLIB_PORTS_PinOpenDrainDisable(PORTS_ID_0, PORT_CHANNEL_C, PORTS_BIT_POS_4);

     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPortsOpenDrain in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_PinOpenDrainDisable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     PORTS_DATA_TYPE PLIB_PORTS_ReadLatched
     (
         PORTS_MODULE_ID index,
         PORTS_CHANNEL channel
     )
   Summary:
     Reads and returns data from the selected Latch.
   Description:
     This function reads and returns the data from the selected Latch.
     This function does not perform atomic register access.

   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the Ports channel A, B, C, etc.
   Returns:
     Latch read data.
   Example:
     <code>
     // Read latch C
     PORTS_DATA_TYPE bitStatus = PLIB_PORTS_ReadLatched(PORTS_ID_0, PORT_CHANNEL_C);

     </code>
   Remarks:
     For reading the Live data, PLIB_PORTS_Read function should be used.

     This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsLatchRead in your application to determine whether
         this feature is available.
 */

 PORTS_DATA_TYPE
   PLIB_PORTS_ReadLatched (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ) ;
 // *****************************************************************************
 /* Function:
     PORTS_DATA_TYPE PLIB_PORTS_Read( PORTS_MODULE_ID index, PORTS_CHANNEL channel )
   Summary:
     Reads the selected digital port.
   Description:
     This function reads from the selected digital port.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the Ports channel A, B, C, etc.
   Returns:
     data on a port with width PORTS_DATA_TYPE
   Example:
     <code>

     // Read PORT C
     PORTS_DATA_TYPE readData = PLIB_PORTS_Read(PORTS_ID_0, PORT_CHANNEL_C);

     </code>
   Remarks:
     For reading the Latched data, PLIB_PORTS_ReadLatched function should be used.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPortsRead in your application to determine whether
         this feature is available.
 */

 PORTS_DATA_TYPE
   PLIB_PORTS_Read (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_Write( PORTS_MODULE_ID index, PORTS_CHANNEL channel,
                            PORTS_DATA_TYPE value )
   Summary:
     Writes the selected digital port/latch.
   Description:
     This function writes to the selected digital port/latch.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the Ports channel A, B, C, etc.
     value - Value to be written into a port of width PORTS_DATA_TYPE
   Returns:
     None.
   Example:
     <code>

     // Write 0x12 into PORT C
     PLIB_PORTS_Write(PORTS_ID_0, PORT_CHANNEL_C, 0x12);

     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPortsWrite in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_Write (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_DATA_TYPE value ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_Set( PORTS_MODULE_ID index, PORTS_CHANNEL channel,
                          PORTS_DATA_TYPE value,
                          PORTS_DATA_MASK mask )
   Summary:
     Sets the selected bits of the port.
   Description:
     This function performs an 'AND' operation on the value and mask parameters,
         and then sets the bits in the port channel that were set by the result of the
         'AND' operation.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the Ports channel A, B, C, etc.
     value - Consists of information about which port bit has to be
                       set and which not
     mask - Identifies the bits which could be intended for setting
   Returns:
     None.
   Example:
     <code>

     // MY_VALUE - 0x1234
     PORTS_DATA_MASK myMask = (PORTS_DATA_MASK)0x00FF;

     // Set the PORT C bit positions 2,4 and 5 (0x0034 = b0000 0000 0011 0100)
     PLIB_PORTS_Set(MY_PORTS_INSTANCE, PORT_CHANNEL_C, MY_VALUE, myMask);

     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPortsWrite in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_Set (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_DATA_TYPE value ,
   PORTS_DATA_MASK mask ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_Toggle( PORTS_MODULE_ID index, PORTS_CHANNEL channel,
                             PORTS_DATA_MASK toggleMask )
   Summary:
     Toggles the selected digital port/latch.
   Description:
     This function toggles the selected digital port/latch.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the Ports channel A, B, C, etc.
     toggleMask - Identifies the bits to be toggled
   Returns:
     None.
   Example:
     <code>

     // Toggles the three least significant Port C bits
     PLIB_PORTS_Toggle(PORTS_ID_0, PORT_CHANNEL_C, 0x0007);

     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPortsWrite in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_Toggle (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_DATA_MASK toggleMask ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_Clear( PORTS_MODULE_ID index, PORTS_CHANNEL channel,
                            PORTS_DATA_MASK clearMask )
   Summary:
     Clears the selected digital port/latch bits.
   Description:
     This function clears the selected digital port/latch bits.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the Ports channel A, B, C, etc.
     clearMask - Identifies the bits to be cleared
   Returns:
     None.
   Example:
     <code>

     // Clears the three least significant Port C bits
     PLIB_PORTS_Clear(PORTS_ID_0, PORT_CHANNEL_C, 0x0007);

     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPortsWrite in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_Clear (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_DATA_MASK clearMask ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_DirectionInputSet( PORTS_MODULE_ID index, PORTS_CHANNEL channel,
                                        PORTS_DATA_MASK mask )
   Summary:
     Makes the selected pins direction input.
   Description:
     This function makes the selected pins direction input.
     This function does not perform atomic register access.

   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the Ports channel A, B, C, etc.
     mask - Identifies the pins direction that has to be made input
   Returns:
     None.
   Example:
     <code>

     // Make RC0, RC1 and RC2 pins as Input
     PLIB_PORTS_DirectionInputSet(PORTS_ID_0, PORT_CHANNEL_C, 0x0007);

     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPortsDirection in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_DirectionInputSet (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_DATA_MASK mask ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_DirectionOutputSet( PORTS_MODULE_ID index, PORTS_CHANNEL channel,
                                         PORTS_DATA_MASK mask )
   Summary:
     Makes the selected pins direction output.
   Description:
     This function makes the selected pins direction output.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the Ports channel A, B, C, etc.
     mask - Identifies the pins direction that has to be made output
   Returns:
     None.
   Example:
     <code>

     // Make RC0, RC1 and RC2 pins as Output
     PLIB_PORTS_DirectionOutputSet(PORTS_ID_0, PORT_CHANNEL_C, 0x0007);

     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPortsDirection in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_DirectionOutputSet (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_DATA_MASK mask ) ;
 // *****************************************************************************
 /* Function:
     PORTS_DATA_MASK PLIB_PORTS_DirectionGet( PORTS_MODULE_ID index, PORTS_CHANNEL channel )
   Summary:
     Reads the direction of the selected digital port.
   Description:
     This function reads the direction of the selected digital port.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the Ports channel A, B, C, etc.
   Returns:
     Direction of the selected port of type PORTS_DATA_MASK
   Example:
     <code>

     // Reads the direction of Port C pins
     PORTS_DATA_MASK readDir = PLIB_PORTS_DirectionGet(PORTS_ID_0, PORT_CHANNEL_C);

     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPortsDirection in your application to determine whether
         this feature is available.
 */

 PORTS_DATA_MASK
   PLIB_PORTS_DirectionGet (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_OpenDrainEnable( PORTS_MODULE_ID index, PORTS_CHANNEL channel,
                                      PORTS_DATA_MASK mask )
   Summary:
     Enables the open drain functionality for the selected port pins.
   Description:
     This function enables the open drain functionality for the selected port pins.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the Ports channel A, B, C, etc.
     mask - Identifies the pins for the open drain to be enabled
   Returns:
     None.
   Example:
     <code>

     // Enable Open Drain for RC0, RC1 and RC2 pins
     PLIB_PORTS_OpenDrainEnable(PORTS_ID_0, PORT_CHANNEL_C, 0x0007);

     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPortsOpenDrain in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_OpenDrainEnable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_DATA_MASK mask ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_OpenDrainDisable( PORTS_MODULE_ID index, PORTS_CHANNEL channel,
                                       PORTS_DATA_MASK mask )
   Summary:
     Disables the open drain functionality for the selected port.
   Description:
     This function disables the open drain functionality for the selected port.
     This function does not perform atomic register access.

   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the Ports channel A, B, C, etc.
     mask - Identifies the pins for the open drain to be disabled
   Returns:
     None.
   Example:
     <code>

     // Disable Open Drain for RC0, RC1 and RC2 pins
     PLIB_PORTS_OpenDrainDisable(PORTS_ID_0, PORT_CHANNEL_C, 0x0007);

     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPortsOpenDrain in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_OpenDrainDisable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_DATA_MASK mask ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_ChannelModeSelect
     (
         PORTS_MODULE_ID index,
             PORTS_CHANNEL channel,
         PORTS_DATA_MASK modeMask,
         PORTS_PIN_MODE mode
     );
   Summary:
     Enables the selected channel pins as analog or digital.
   Description:
     This function enables the selected channel pins as analog or digital.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
     modeMask - Identifies the pins whose mode has to be modified.
                       Modes of the pins whose corresponding bit is '1' get
                       modified, mode of the other pins remains the same.
     mode - Possible values of PORTS_PIN_MODE (Analog or Digital)
   Returns:
     None.
   Example:
     <code>

     // Make pins RC5, RC8 and RC13 Analog
     PLIB_PORTS_ChannelModeSelect(PORTS_ID_0, PORT_CHANNEL_C, 0x2120, PORTS_PIN_MODE_ANALOG);

     </code>
   Remarks:
     This function is only available in devices with PPS. For Non-PPS devices, use the
     PLIB_PORTS_AnPinsModeSelect function.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPinModePerPort in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_ChannelModeSelect (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_DATA_MASK modeMask ,
   PORTS_PIN_MODE mode ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_ChannelChangeNoticePullUpEnable
      (
         PORTS_MODULE_ID index,
         PORTS_CHANNEL channel,
         PORTS_DATA_MASK mask
      );
   Summary:
     Enables Change Notice pull-up for the selected channel pins.
   Description:
     This function enables the Change Notice pull-up for the selected
     channel pins.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
     mask - Identifies the pins of the pull-up to be enabled
   Returns:
     None.
   Example:
     <code>

     // Enable pull-up for RC5, RC8 and RC13 pins
     PLIB_PORTS_ChannelChangeNoticePullUpEnable(PORTS_ID_0, PORT_CHANNEL_C,
                                                                 0x2120);
     </code>
   Remarks:
     This function is only available in devices with PPS. For Non-PPS devices, use the
     PLIB_PORTS_CnPinsPullUpEnable function.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticePullUpPerPort in your application to
     determine whether this feature is available.
 */

 void
   PLIB_PORTS_ChannelChangeNoticePullUpEnable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_DATA_MASK mask ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_ChannelChangeNoticePullUpDisable
      (
         PORTS_MODULE_ID index,
         PORTS_CHANNEL channel,
         PORTS_DATA_MASK mask
      );
   Summary:
     Disables Change Notice pull-up for the selected channel pins.
   Description:
     This function Disables the Change Notice pull-up for the selected
     channel pins.
     PLIB_PORTS_ChannelChangeNoticePullUpDisable
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
     mask - Identifies the pins of the pull-up to be disabled
   Returns:
     None.
   Example:
     <code>

     // Disable pull-up for RC5, RC8 and RC13 pins
     PLIB_PORTS_ChannelChangeNoticePullUpDisable(PORTS_ID_0, PORT_CHANNEL_C,
                                                                 0x2120);
     </code>
   Remarks:
     This function is only available in devices with PPS. For Non-PPS devices, use the
     PLIB_PORTS_CnPinsPullUpDisable function.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticePullUpPerPort in your application to
     determine whether this feature is available.
 */

 void
   PLIB_PORTS_ChannelChangeNoticePullUpDisable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_DATA_MASK mask ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_ChannelChangeNoticePullDownEnable
      (
         PORTS_MODULE_ID index,
         PORTS_CHANNEL channel,
         PORTS_DATA_MASK mask
      );
   Summary:
     Enables Change Notice pull-down for the selected channel pins.
   Description:
     This function enables the Change Notice pull-down for the selected
     channel pins.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
     mask - Identifies the pins for the pull-down to be enabled
   Returns:
     None.
   Example:
     <code>

     // Enable pull-down for RC5, RC8 and RC13 pins
     PLIB_PORTS_ChannelChangeNoticePullDownEnable(PORTS_ID_0, PORT_CHANNEL_C,
                                                                 0x2120);
     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticePullDownPerPort in your application to
     determine whether this feature is available.
 */

 void
   PLIB_PORTS_ChannelChangeNoticePullDownEnable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_DATA_MASK mask ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_ChannelChangeNoticePullDownDisable
      (
         PORTS_MODULE_ID index,
         PORTS_CHANNEL channel,
         PORTS_DATA_MASK mask
      );
   Summary:
     Disables Change Notice pull-down for the selected channel pins.
   Description:
     This function Disables the Change Notice pull-down for the selected
     channel pins.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
     mask - Identifies the pins for the pull-down to be disabled
   Returns:
     None.
   Example:
     <code>

     // Disable pull-down for RC5, RC8 and RC13 pins
     PLIB_PORTS_ChannelChangeNoticePullDownDisable(PORTS_ID_0, PORT_CHANNEL_C,
                                                                 0x2120);
     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticePullDownPerPort in your application to
     determine whether this feature is available.
 */

 void
   PLIB_PORTS_ChannelChangeNoticePullDownDisable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_DATA_MASK mask ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_ChannelChangeNoticeEnable
     (
         PORTS_MODULE_ID index,
         PORTS_CHANNEL channel,
         PORTS_DATA_MASK mask
     );
   Summary:
     Enables CN interrupt for the selected pins of a channel.
   Description:
     This function enables Change Notice interrupt for the selected port
     pins of a channel.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
     mask - Identifies the pins for which change notification is
                       to be enabled
   Returns:
     None.
   Example:
     <code>

     // Enable CN interrupt for RC5, RC8 and RC13 pins
     PLIB_PORTS_ChannelChangeNoticeEnable(PORTS_ID_0, PORT_CHANNEL_C, 0x2120);

     </code>
   Remarks:
     This function is only available in devices with PPS. For Non-PPS devices, use the
     PLIB_PORTS_CnPinsEnable function.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticeIntPerPort in your application to
     determine whether this feature is available.
 */

 void
   PLIB_PORTS_ChannelChangeNoticeEnable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_DATA_MASK mask ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_ChannelChangeNoticeDisable
     (
         PORTS_MODULE_ID index,
         PORTS_CHANNEL channel,
         PORTS_DATA_MASK mask
     );
   Summary:
     Disables CN interrupt for the selected pins of a channel.
   Description:
     This function Disables Change Notice interrupt for the selected port
     pins of a channel.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
     mask - Identifies the pins for which change notification is
                       to be disabled
   Returns:
     None.
   Example:
     <code>

     // Disable CN interrupt for RC5, RC8 and RC13 pins
     PLIB_PORTS_ChannelChangeNoticeDisable(PORTS_ID_0, PORT_CHANNEL_C, 0x2120);

     </code>
   Remarks:
         This function is only available in devices with PPS. For Non-PPS devices, use the
     PLIB_PORTS_CnPinsDisable function.

     This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticeIntPerPort in your application to
     determine whether this feature is available.
 */

 void
   PLIB_PORTS_ChannelChangeNoticeDisable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_DATA_MASK mask ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_AnPinsModeSelect
      (
          PORTS_MODULE_ID index,
          PORTS_AN_PIN anPins,
          PORTS_PIN_MODE mode
      );
   Summary:
     Enables the selected AN pins as analog or digital.
   Description:
     This function enables the selected AN pins as analog or digital.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     anPins - AN pins whose mode is to be changed. Multiple AN pins
                       can be ORed.
     mode - Possible values of PORTS_PIN_MODE (Analog or Digital)
   Returns:
     None.
   Example:
     <code>

     // Make pins AN5, AN8 and AN13 Analog
     PLIB_PORTS_AnPinsModeSelect(PORTS_ID_0, PORTS_AN_PIN_5 |
                                     PORTS_AN_PIN_8 |
                PORTS_AN_PIN_13,
                PORTS_PIN_MODE_ANALOG);

     </code>
   Remarks:
     This function is only available in devices without PPS feature. For PPS
     devices, use the PLIB_PORTS_ChannelModeSelect function.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsAnPinsMode in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_AnPinsModeSelect (
   PORTS_MODULE_ID index ,
   PORTS_AN_PIN anPins ,
   PORTS_PIN_MODE mode ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_CnPinsPullUpEnable
      (
         PORTS_MODULE_ID index,
         PORTS_CN_PIN cnPins
      );
   Summary:
     Enables Change Notice pull-up for the selected channel pins.
   Description:
     This function enables the Change Notice pull-up for the selected
     channel pins.
     This function performs atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     cnPins - CN pins whose pull-up is to be enabled. Multiple CN pins
                       can be ORed.
   Returns:
     None.
   Example:
     <code>

     // Enable pull-up for CN5, CN8 and CN13 pins
     PLIB_PORTS_CnPinsPullUpEnable(PORTS_ID_0, CHANGE_NOTICE_PIN_5 |
                                                   CHANGE_NOTICE_PIN_8 |
                     CHANGE_NOTICE_PIN_13);

     </code>
   Remarks:
     This function is only available in devices without PPS feature. For PPS
     devices, use the PLIB_PORTS_ChannelChangeNoticePullUpEnable function.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticePullUp in your application to
     determine whether this feature is available.
 */

 void
   PLIB_PORTS_CnPinsPullUpEnable (
   PORTS_MODULE_ID index ,
   PORTS_CN_PIN cnPins ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_CnPinsPullUpDisable
     (
         PORTS_MODULE_ID index,
         PORTS_CN_PIN cnPins
     );
   Summary:
     Disables Change Notice pull-up for the selected channel pins.
   Description:
     This function Disables the Change Notice pull-up for the selected
     channel pins.
     This function performs atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     cnPins - CN pins whose pull-up is to be disabled. Multiple CN pins
                       can be ORed.
   Returns:
     None.
   Example:
     <code>

     // Disable pull-up for CN5, CN8 and CN13 pins
     PLIB_PORTS_CnPinsPullUpDisable(PORTS_ID_0,
                                        CHANGE_NOTICE_PIN_5 |
                   CHANGE_NOTICE_PIN_8 |
                   CHANGE_NOTICE_PIN_13);

     </code>
   Remarks:
     This function is only available in devices without PPS feature. For PPS
     devices, use the PLIB_PORTS_ChannelChangeNoticePullUpDisable function.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticePullUp in your application to
     determine whether this feature is available.
 */

 void
   PLIB_PORTS_CnPinsPullUpDisable (
   PORTS_MODULE_ID index ,
   PORTS_CN_PIN cnPins ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_CnPinsEnable
     (
         PORTS_MODULE_ID index,
         PORTS_CN_PIN cnPins
     );
   Summary:
     Enables CN interrupt for the selected pins of a channel.
   Description:
     This function enables Change Notice interrupt for the selected port
     pins of a channel.
     This function performs atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     cnPins - CN pins to be enabled. Multiple CN pins can be ORed.
   Returns:
     None.
   Example:
     <code>

     // Enable CN interrupt for CN5, CN8 and CN13 pins
     PLIB_PORTS_CnPinsEnable(PORTS_ID_0,
                                 CHANGE_NOTICE_PIN_5 |
               CHANGE_NOTICE_PIN_8 |
               CHANGE_NOTICE_PIN_13);

     </code>
   Remarks:
     This function is only available in devices without PPS feature. For PPS
     devices, use the PLIB_PORTS_ChannelChangeNoticeEnable function.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPinChangeNotice in your application to
     determine whether this feature is available.
 */

 void
   PLIB_PORTS_CnPinsEnable (
   PORTS_MODULE_ID index ,
   PORTS_CN_PIN cnPins ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_CnPinsDisable
     (
         PORTS_MODULE_ID index,
         PORTS_CN_PIN cnPins
     );
   Summary:
     Disables CN interrupt for the selected pins of a channel.
   Description:
     This function Disables Change Notice interrupt for the selected port
     pins of a channel.
     This function performs atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     cnPins - CN pins to be disabled. Multiple CN pins can be ORed.
   Returns:
     None.
   Example:
     <code>

     // Disable CN interrupt for CN5, CN8 and CN13 pins
     PLIB_PORTS_CnPinsDisable(PORTS_ID_0,
                                  CHANGE_NOTICE_PIN_5 |
                CHANGE_NOTICE_PIN_8 |
                CHANGE_NOTICE_PIN_13);

     </code>
   Remarks:
     This function is only available in devices without PPS feature. For PPS
     devices, use the PLIB_PORTS_ChannelChangeNoticeDisable function.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPinChangeNotice in your application to
     determine whether this feature is available.
 */

 void
   PLIB_PORTS_CnPinsDisable (
   PORTS_MODULE_ID index ,
   PORTS_CN_PIN cnPins ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_ChangeNoticeEnable( PORTS_MODULE_ID index )
   Summary:
     Global Change Notice enable.
   Description:
     This function enables the global Change Notice feature.
     This function performs atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>

     // Enable Change Notification
     PLIB_PORTS_ChangeNoticeEnable(PORTS_ID_0);

     </code>
   Remarks:
     This function is only available in devices without PPS. For PPS devices, use the
     PLIB_PORTS_ChangeNoticePerPortTurnOn function.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNotice in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_ChangeNoticeEnable (
   PORTS_MODULE_ID index ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_ChangeNoticeDisable( PORTS_MODULE_ID index )
   Summary:
     Global Change Notice disable.
   Description:
     This function disables the global Change Notice feature.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>

     // Disable Change Notification
     PLIB_PORTS_ChangeNoticeDisable(PORTS_ID_0);

     </code>
   Remarks:
     This function is only available in devices without PPS. For PPS devices, use the
     PLIB_PORTS_ChangeNoticePerPortTurnOff function.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNotice in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_ChangeNoticeDisable (
   PORTS_MODULE_ID index ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_PinChangeNoticeEnable( PORTS_MODULE_ID index,
                                            PORTS_CHANGE_NOTICE_PIN pinNum )
   Summary:
     Port pin Change Notice interrupt enable.
   Description:
     This function enables the port pin Change Notice feature.
     This function performs atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     pinNum - Possible values of PORTS_CHANGE_NOTICE_PIN
   Returns:
     None.
   Example:
     <code>

     // Enable Change Notice interrupt for pin CN13
     PLIB_PORTS_PinChangeNoticeEnable(PORTS_ID_0, CN13);

     </code>
   Remarks:
     This function is only available in devices without PPS. For PPS devices, use the
     PLIB_PORTS_PinChangeNoticePerPortEnable function.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPinChangeNotice in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_PinChangeNoticeEnable (
   PORTS_MODULE_ID index ,
   PORTS_CHANGE_NOTICE_PIN pinNum ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_PinChangeNoticeDisable( PORTS_MODULE_ID index,
                                             PORTS_CHANGE_NOTICE_PIN pinNum )
   Summary:
     Port pin Change Notice disable.
   Description:
     This function disables the port pin Change Notice feature.
     This function performs atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     pinNum - Possible values of PORTS_CHANGE_NOTICE_PIN
   Returns:
     None.
   Example:
     <code>

     // Disable Change Notice interrupt for pin CN13
     PLIB_PORTS_PinChangeNoticeDisable(PORTS_ID_0, CN13);

     </code>
   Remarks:
     This function is only available in devices without PPS. For PPS devices, use the
     PLIB_PORTS_PinChangeNoticePerPortDisable function.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsPinChangeNotice in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_PinChangeNoticeDisable (
   PORTS_MODULE_ID index ,
   PORTS_CHANGE_NOTICE_PIN pinNum ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_ChangeNoticeInIdleEnable( PORTS_MODULE_ID index )
   Summary:
     CPU Idle mode does not affect Change Notice operation.
   Description:
     This function makes sure that Change Notice feature continues working in
     Idle mode.
     This function performs atomic register access.

   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>

     // Change notification feature will be working even when CPU goes to
     // Idle mode
     PLIB_PORTS_ChangeNoticeInIdleEnable(PORTS_ID_0);

     </code>
   Remarks:
     This function is only available in devices without PPS. For PPS devices, use the
     PLIB_PORTS_ChangeNoticeInIdlePerPortEnable function.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticeInIdle in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_ChangeNoticeInIdleEnable (
   PORTS_MODULE_ID index ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_ChangeNoticeInIdleDisable( PORTS_MODULE_ID index )
   Summary:
     CPU Idle halts the Change Notice operation.
   Description:
     This function halts the Change Notice operation when the CPU enters
     Idle mode.
     This function performs atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
     // Halts the Change notification operation when CPU enters Idle mode
     PLIB_PORTS_ChangeNoticeInIdleDisable(PORTS_ID_0);

     </code>
   Remarks:
     This function is only available in devices without PPS. For PPS devices, use the
     PLIB_PORTS_ChangeNoticeInIdlePerPortDisable function.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticeInIdle in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_ChangeNoticeInIdleDisable (
   PORTS_MODULE_ID index ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_ChangeNoticePullUpEnable( PORTS_MODULE_ID index,
                                               PORTS_CHANGE_NOTICE_PIN pinNum )
   Summary:
     Enable pull-up on input change.
   Description:
     This function enables pull-up on selected input change notification pin.
     This function performs atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     pinNum - Possible values of PORTS_CHANGE_NOTICE_PIN
   Returns:
     None.
   Example:
     <code>

     // Enable pull-up on pin CN13
     PLIB_PORTS_ChangeNoticePullUpEnable(PORTS_ID_0, CN13);

     </code>
   Remarks:
     This function is only available in devices without PPS. For PPS devices, use the
     PLIB_PORTS_ChangeNoticePullUpPerPortEnable function.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticePullUp in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_ChangeNoticePullUpEnable (
   PORTS_MODULE_ID index ,
   PORTS_CHANGE_NOTICE_PIN pinNum ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_ChangeNoticePullUpDisable( PORTS_MODULE_ID index,
                                                PORTS_CHANGE_NOTICE_PIN pinNum )
   Summary:
     Disable pull-up on input change.
   Description:
     This function disables pull-up on selected input change notification pin.
     This function performs atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     pinNum - Possible values of PORTS_CHANGE_NOTICE_PIN
   Returns:
     None.
   Example:
     <code>

     // Disable pull-up on pin CN13
     PLIB_PORTS_ChangeNoticePullUpDisable(PORTS_ID_0, CN13);

     </code>
   Remarks:
     This function is only available in devices without PPS. For PPS devices, use the
     PLIB_PORTS_ChangeNoticePullUpPerPortDisable function.

         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticePullUp in your application to determine whether
         this feature is available.
 */

 void
   PLIB_PORTS_ChangeNoticePullUpDisable (
   PORTS_MODULE_ID index ,
   PORTS_CHANGE_NOTICE_PIN pinNum ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_ChannelSlewRateSelect
     (
         PORTS_MODULE_ID index,
             PORTS_CHANNEL channel,
         PORTS_DATA_MASK channelMask,
         PORTS_PIN_SLEW_RATE slewRate
     );
   Summary:
     Selects the slew rate for selected channel pins.
   Description:
     This function selects the slew rate for selected channel pins.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
     channelMask - Identifies the pins for which slew rate has to be modified.
                       Slew rate of the pins which corresponding bit is "1" get
                       modified, slew rate of the other pins remains the same.
     slewRate - One of the possible values of PORTS_PIN_SLEW_RATE.
   Returns:
     None.
   Example:
     <code>

     // Make slew rate of pins RC5, RC8 and RC13 slowest
     PLIB_PORTS_ChannelSlewRateSelect(PORTS_ID_0,
                                          PORT_CHANNEL_C,
                  0x2120,
                  PORTS_PIN_SLEW_RATE_SLOWEST);

     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsSlewRateControl in your application to determine
     whether this feature is available.
 */

 void
   PLIB_PORTS_ChannelSlewRateSelect (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_DATA_MASK channelMask ,
   PORTS_PIN_SLEW_RATE slewRate ) ;
 // *****************************************************************************
 /* Function:
 PORTS_PIN_SLEW_RATE PLIB_PORTS_PinSlewRateGet
     (
         PORTS_MODULE_ID index,
             PORTS_CHANNEL channel,
         PORTS_BIT_POS bitPos
     );
   Summary:
     Gets the slew rate for selected port pin.
   Description:
     This function gets the slew rate of selected port pin.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
     bitPos - One of the possible values of PORTS_BIT_POS.
   Returns:
     One of the possible values of PORTS_PIN_SLEW_RATE.
   Example:
     <code>
     PORTS_PIN_SLEW_RATE slewRate;

     // Get the slew rate of pin RC1
     slewRate = PLIB_PORTS_PinSlewRateGet(PORTS_ID_0, PORT_CHANNEL_C, PORTS_BIT_POS_1);

     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsSlewRateControl in your application to determine
     whether this feature is available.
 */

 PORTS_PIN_SLEW_RATE
   PLIB_PORTS_PinSlewRateGet (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_ChannelChangeNoticeMethodSelect
     (
         PORTS_MODULE_ID index,
             PORTS_CHANNEL channel,
         PORTS_CHANGE_NOTICE_METHOD changeNoticeMethod
     );
   Summary:
     Selects the Change Notice style for selected port channel.
   Description:
     This function selects the Change Notice style (or method) for selected port
     channel. It allows user to select whether the Change Notice detection will
     happen based on edge transition or level transition on all the CN pins of a
     particular channel.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
     changeNoticeMethod - One of the possible values of PORTS_CHANGE_NOTICE_METHOD.
   Returns:
     None.
   Example:
     <code>
     PLIB_PORTS_ChannelChangeNoticeMethodSelect(PORTS_ID_0, PORT_CHANNEL_C,
                                             PORTS_CHANGE_NOTICE_METHOD_EDGE_DETECT);
     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChannelChangeNoticeMethod in your application to determine
     whether this feature is available.
 */

 void
   PLIB_PORTS_ChannelChangeNoticeMethodSelect (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_CHANGE_NOTICE_METHOD changeNoticeMethod ) ;
 // *****************************************************************************
 /* Function:
     PORTS_CHANGE_NOTICE_METHOD PLIB_PORTS_ChannelChangeNoticeMethodGet
     (
         PORTS_MODULE_ID index,
             PORTS_CHANNEL channel
     );
   Summary:
     Gets the Change Notice style for the selected port channel.
   Description:
     This function gets the Change Notice style (or method) for the selected port
     channel.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
   Returns:
     One of the possible values of PORTS_CHANGE_NOTICE_METHOD.
   Example:
     <code>
     PORTS_CHANGE_NOTICE_METHOD changeNoticeMethod;
     changeNoticeMethod = PLIB_PORTS_ChannelChangeNoticeMethodGet(PORTS_ID_0, PORT_CHANNEL_C);
     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChannelChangeNoticeMethod in your application to determine
     whether this feature is available.
 */

 PORTS_CHANGE_NOTICE_METHOD
   PLIB_PORTS_ChannelChangeNoticeMethodGet (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ) ;
 // *****************************************************************************
 /* Function:
         void PLIB_PORTS_ChannelChangeNoticeEdgeEnable
     (
         PORTS_MODULE_ID index,
         PORTS_CHANNEL channel,
         PORTS_DATA_MASK edgeRisingMask,
         PORTS_DATA_MASK edgeFallingMask
     );
   Summary:
     Enables selected type of edge for selected CN pins.
   Description:
     This function Enables selected type of edge (falling or rising) for
     selected CN pins of a port channel.
     This function does not perform atomic register access.
   Precondition:
     Change Notice method should be selected as
     "PORTS_CHANGE_NOTICE_METHOD_EDGE_DETECT" using
     PLIB_PORTS_ChannelChangeNoticeMethodSelect before using this function.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
     edgeRisingMask - Identifies the pins for which Change Notice has to be
                       enabled for rising edge. Change Notice interrupt at rising
                       edge is enabled for the pins which corresponding bit is
                       '1', for the other pins it remains the same.
     edgeFallingMask - Identifies the pins for which Change Notice has to be
                       enabled for falling edge. Change Notice interrupt at
                       falling edge is enabled for the pins which corresponding
                       bit is '1', for the other pins it remains the same.
   Returns:
     None.
   Example:
     <code>
     // Enable Change Notice at rising edge for RC1 pin and at falling edge for
     // RC1 & RC5 pins.
     PLIB_PORTS_ChannelChangeNoticeEdgeEnable(PORTS_ID_0, PORT_CHANNEL_C, 0x0002, 0x0022);
     </code>
   Remarks:
         This feature is not available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticeEdgeControl in your application to determine
     whether this feature is available.
 */

 void
   PLIB_PORTS_ChannelChangeNoticeEdgeEnable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_DATA_MASK edgeRisingMask ,
   PORTS_DATA_MASK edgeFallingMask ) ;
 // *****************************************************************************
 /* Function:
     void PLIB_PORTS_ChannelChangeNoticeEdgeDisable
     (
         PORTS_MODULE_ID index,
         PORTS_CHANNEL channel,
         PORTS_DATA_MASK edgeRisingMask,
         PORTS_DATA_MASK edgeFallingMask
     );
   Summary:
     Disables selected type of edge for selected CN pins.
   Description:
     This function Disables selected type of edge (falling or rising) for
     selected CN pins of a port channel.
     This function does not perform atomic register access.
   Precondition:
     Change Notice method should be selected as
     "PORTS_CHANGE_NOTICE_METHOD_EDGE_DETECT" using
     PLIB_PORTS_ChannelChangeNoticeMethodSelect before using this function.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
     edgeRisingMask - Identifies the pins for which Change Notice has to be
                       enabled for rising edge. Change notice interrupt at rising
                       edge is enabled for the pins which corresponding bit is
                       '1', for the other pins it remains the same.
     edgeFallingMask - Identifies the pins for which Change Notice has to be
                       enabled for falling edge. Change notice interrupt at
                       falling edge is enabled for the pins which corresponding
                       bit is '1', for the other pins it remains the same.
   Returns:
     None.
   Example:
     <code>
     // Disable Change Notice at rising edge for RC1 pin and at falling edge for
     // RC1 & RC5 pins.
     PLIB_PORTS_ChannelChangeNoticeEdgeDisable(PORTS_ID_0, PORT_CHANNEL_C, 0x0002, 0x0022);
     </code>
   Remarks:
         This feature is not available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticeEdgeControl in your application to determine
     whether this feature is available.
 */

 void
   PLIB_PORTS_ChannelChangeNoticeEdgeDisable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_DATA_MASK edgeRisingMask ,
   PORTS_DATA_MASK edgeFallingMask ) ;
 // *****************************************************************************
 /* Function:
     bool PLIB_PORTS_PinChangeNoticeEdgeIsEnabled
     (
         PORTS_MODULE_ID index,
         PORTS_CHANNEL channel,
         PORTS_BIT_POS bitPos,
         PORTS_CHANGE_NOTICE_EDGE cnEdgeType
     );
   Summary:
     Check if Change Notice edge is enabled or not.
     This function does not perform atomic register access.
   Description:
     This function checks if selected type of Change Notice edge is enabled on a
     particular port pin or not.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
     bitPos - One of the possible values of PORTS_BIT_POS.
     cnEdgeType - Type of the edge which has to be checked.

   Returns:
     - true - Selected type of Change Notice Edge is enabled.
     - false - Selected type of Change Notice Edge is not enabled.

   Example:
     <code>
     // Check if Change Notice at rising edge is enabled or not for pin RC1.
     if (PLIB_PORTS_PinChangeNoticeEdgeIsEnabled(PORTS_ID_0, PORT_CHANNEL_C, PORTS_BIT_POS_1, PORTS_CHANGE_NOTICE_EDGE_RISING))
     {
         // do something
     }
     </code>
   Remarks:
         This feature is not available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticeEdgeControl in your application to determine
     whether this feature is available.
 */

 bool
   PLIB_PORTS_PinChangeNoticeEdgeIsEnabled (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ,
   PORTS_CHANGE_NOTICE_EDGE cnEdgeType ) ;
 // *****************************************************************************
 /* Function:
     bool PLIB_PORTS_PinChangeNoticeEdgeHasOccurred
     (
         PORTS_MODULE_ID index,
         PORTS_CHANNEL channel,
         PORTS_BIT_POS bitPos
     );
   Summary:
     Check Change Notice edge status.
   Description:
     This function checks whether or no a Change Notice edge transition has occurred
     on the selected port pin.
     This function does not perform atomic register access.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
     bitPos - One of the possible values of PORTS_BIT_POS

   Returns:
     - true - Change Notice edge transition has occurred
     - false - Change Notice edge transition has not occurred

   Example:
     <code>
     // Check if Change Notice edge transition has occurred for pin RC1.
     if (PLIB_PORTS_PinChangeNoticeEdgeHasOccurred(PORTS_ID_0, PORT_CHANNEL_C, PORTS_BIT_POS_1))
     {
         // do something
     }
     </code>
   Remarks:
         This feature is not available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticeEdgeStatus in your application to determine
     whether this feature is available.
 */

 bool
   PLIB_PORTS_PinChangeNoticeEdgeHasOccurred (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: Ports Peripheral Library Exists Functions
 // *****************************************************************************
 // *****************************************************************************
 /* The functions below indicate the existence of the features on the device.
 */
 //******************************************************************************
 /* Function:
     PLIB_PORTS_ExistsRemapInput( PORTS_MODULE_ID index )
   Summary:
     Identifies whether the RemapInput feature exists on the Ports module.
   Description:
     This function identifies whether the RemapInput feature is available on the
         Ports module.
     When this function returns true, this function is supported on the device:
     - PLIB_PORTS_RemapInput
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The RemapInput feature is supported on the device
     - false - The RemapInput feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_PORTS_ExistsRemapInput (
   PORTS_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_PORTS_ExistsRemapOutput( PORTS_MODULE_ID index )
   Summary:
     Identifies whether the RemapOutput feature exists on the Ports module.
   Description:
     This function identifies whether the RemapOutput feature is available on the
         Ports module.
     When this function returns true, this function is supported on the device:
     - PLIB_PORTS_RemapOutput
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The RemapOutput feature is supported on the device
     - false - The RemapOutput feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_PORTS_ExistsRemapOutput (
   PORTS_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_PORTS_ExistsPinMode( PORTS_MODULE_ID index )
   Summary:
     Identifies whether the PinMode feature exists on the Ports module.
   Description:
     This function identifies whether the PinMode (Analog Pin or Digital Pin)
     feature is available on the Ports module.
     When this function returns true, this function is supported on the device:
     - PLIB_PORTS_PinModeSelect
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The PinMode feature is supported on the device
     - false - The PinMode feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_PORTS_ExistsPinMode (
   PORTS_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_PORTS_ExistsAnPinsMode( PORTS_MODULE_ID index )
   Summary:
     Identifies whether the AnPinsMode feature exists on the Ports module.
   Description:
     This function identifies whether the AnPinsMode feature is available on the
         Ports module.
     When this function returns true, this function is supported on the device:
     - PLIB_PORTS_AnPinsModeSelect
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The AnPinsMode feature is supported on the device
     - false - The AnPinsMode feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_PORTS_ExistsAnPinsMode (
   PORTS_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_PORTS_ExistsPortsRead( PORTS_MODULE_ID index )
   Summary:
     Identifies whether the PortsRead feature exists on the Ports module.
   Description:
     This function identifies whether the PortsRead feature is available on the
         Ports module.
     When this function returns true, these functions are supported on the device:
     - PLIB_PORTS_PinGet
     - PLIB_PORTS_Read
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The PortsRead feature is supported on the device
     - false - The PortsRead feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_PORTS_ExistsPortsRead (
   PORTS_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_PORTS_ExistsLatchRead( PORTS_MODULE_ID index )
   Summary:
     Identifies whether the LatchRead feature exists on the Ports module.
   Description:
     This function identifies whether the LatchRead feature is available on the
         Ports module.
     When this function returns true, these functions are supported on the device:
     - PLIB_PORTS_PinGetLatched
     - PLIB_PORTS_ReadLatched
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The LatchRead feature is supported on the device
     - false - The LatchRead feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_PORTS_ExistsLatchRead (
   PORTS_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_PORTS_ExistsPortsWrite( PORTS_MODULE_ID index )
   Summary:
     Identifies whether the PortsWrite feature exists on the Ports module.
   Description:
     This function identifies whether the PortsWrite feature is available on the
         Ports module.
     When this function returns true, these functions are supported on the device:
     - PLIB_PORTS_PinWrite
     - PLIB_PORTS_PinSet
     - PLIB_PORTS_PinClear
     - PLIB_PORTS_PinToggle
     - PLIB_PORTS_Write
     - PLIB_PORTS_Set
     - PLIB_PORTS_Toggle
     - PLIB_PORTS_Clear
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The PortsWrite feature is supported on the device
     - false - The PortsWrite feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_PORTS_ExistsPortsWrite (
   PORTS_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_PORTS_ExistsPortsDirection( PORTS_MODULE_ID index )
   Summary:
     Identifies whether the PortsDirection feature exists on the Ports module.
   Description:
     This function identifies whether the PortsDirection feature is available on the
         Ports module.
     When this function returns true, these functions are supported on the device:
     - PLIB_PORTS_PinDirectionInputSet
     - PLIB_PORTS_PinDirectionOutputSet
     - PLIB_PORTS_DirectionInputSet
     - PLIB_PORTS_DirectionOutputSet
     - PLIB_PORTS_DirectionGet
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The PortsDirection feature is supported on the device
     - false - The PortsDirection feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_PORTS_ExistsPortsDirection (
   PORTS_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_PORTS_ExistsPortsOpenDrain( PORTS_MODULE_ID index )
   Summary:
     Identifies whether the PortsOpenDrain feature exists on the Ports module.
   Description:
     This function identifies whether the PortsOpenDrain feature is available on
         the Ports module.
     When this function returns true, these functions are supported on the device:
     - PLIB_PORTS_PinOpenDrainEnable
     - PLIB_PORTS_PinOpenDrainDisable
     - PLIB_PORTS_OpenDrainEnable
     - PLIB_PORTS_OpenDrainDisable
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The PortsOpenDrain feature is supported on the device
     - false - The PortsOpenDrain feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_PORTS_ExistsPortsOpenDrain (
   PORTS_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_PORTS_ExistsChangeNotice( PORTS_MODULE_ID index )
   Summary:
     Identifies whether the ChangeNotice feature exists on the Ports module.
   Description:
     This function identifies whether the ChangeNotice feature is available on the
         Ports module.
     When this function returns true, these functions are supported on the device:
     - PLIB_PORTS_ChangeNoticeEnable
     - PLIB_PORTS_ChangeNoticeDisable
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChangeNotice feature is supported on the device
     - false - The ChangeNotice feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_PORTS_ExistsChangeNotice (
   PORTS_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_PORTS_ExistsPinChangeNotice( PORTS_MODULE_ID index )
   Summary:
     Identifies whether the PinChangeNotice feature exists on the Ports module.
   Description:
     This function identifies whether the PinChangeNotice feature is available on
         the Ports module.
     When this function returns true, these functions are supported on the device:
     - PLIB_PORTS_PinChangeNoticeEnable
     - PLIB_PORTS_PinChangeNoticeDisable
     - PLIB_PORTS_CnPinsEnable
     - PLIB_PORTS_CnPinsDisable
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The PinChangeNotice feature is supported on the device
     - false - The PinChangeNotice feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_PORTS_ExistsPinChangeNotice (
   PORTS_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_PORTS_ExistsChangeNoticeInIdle( PORTS_MODULE_ID index )
   Summary:
     Identifies whether the ChangeNoticeInIdle feature exists on the Ports module.
   Description:
     This function identifies whether the ChangeNoticeInIdle feature is available
         on the Ports module.
     When this function returns true, these functions are supported on the device:
     - PLIB_PORTS_ChangeNoticeInIdleEnable
     - PLIB_PORTS_ChangeNoticeInIdleDisable
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChangeNoticeInIdle feature is supported on the device
     - false - The ChangeNoticeInIdle feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_PORTS_ExistsChangeNoticeInIdle (
   PORTS_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_PORTS_ExistsChangeNoticePullUp( PORTS_MODULE_ID index )
   Summary:
     Identifies whether the ChangeNoticePullup feature exists on the Ports module.
   Description:
     This function identifies whether the ChangeNoticePullup feature is available
         on the Ports module.
     When this function returns true, these functions are supported on the device:
     - PLIB_PORTS_ChangeNoticePullUpEnable
     - PLIB_PORTS_ChangeNoticePullUpDisable
     - PLIB_PORTS_CnPinsPullUpEnable
     - PLIB_PORTS_CnPinsPullUpDisable
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChangeNoticePullup feature is supported on the device
     - false - The ChangeNoticePullup feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_PORTS_ExistsChangeNoticePullUp (
   PORTS_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_PORTS_ExistsPinModePerPort( PORTS_MODULE_ID index )
   Summary:
     Identifies whether the PinModePerPort feature exists on the Ports module.
   Description:
     This function identifies whether the PinModePerPort (Analog Pin or Digital Pin)
     feature is available on the Ports module.
     When this function returns true, these functions are supported on the device:
     - PLIB_PORTS_PinModePerPortSelect
     - PLIB_PORTS_ChannelModeSelect
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The PinModePerPort feature is supported on the device
     - false - The PinModePerPort feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_PORTS_ExistsPinModePerPort (
   PORTS_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_PORTS_ExistsChangeNoticePullDownPerPort( PORTS_MODULE_ID index )
   Summary:
     Identifies whether the ChangeNoticePullDownPerPort feature exists on the
         Ports module.
   Description:
     This function identifies whether the ChangeNoticePullDownPerPort feature is
         available on the Ports module.
     When this function returns true, these functions are supported on the device:
     - PLIB_PORTS_ChangeNoticePullDownPerPortEnable
     - PLIB_PORTS_ChangeNoticePullDownPerPortDisable
     - PLIB_PORTS_ChannelChangeNoticePullDownEnable
     - PLIB_PORTS_ChannelChangeNoticePullDownDisable
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChangeNoticePullDownPerPort feature is supported on the device
     - false - The ChangeNoticePullDownPerPort feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_PORTS_ExistsChangeNoticePullDownPerPort (
   PORTS_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_PORTS_ExistsChangeNoticePullUpPerPort( PORTS_MODULE_ID index )
   Summary:
     Identifies whether the ChangeNoticePullUpPerPort feature exists on the Ports
         module.
   Description:
     This function identifies whether the ChangeNoticePullUpPerPort feature is available
         on the Ports module.
     When this function returns true, these functions are supported on the device:
     - PLIB_PORTS_ChangeNoticePullUpPerPortEnable
     - PLIB_PORTS_ChangeNoticePullUpPerPortDisable
     - PLIB_PORTS_ChannelChangeNoticePullUpEnable
     - PLIB_PORTS_ChannelChangeNoticePullUpDisable
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChangeNoticePullUpPerPort feature is supported on the device
     - false - The ChangeNoticePullUpPerPort feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_PORTS_ExistsChangeNoticePullUpPerPort (
   PORTS_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_PORTS_ExistsPinChangeNoticePerPort( PORTS_MODULE_ID index )
   Summary:
     Identifies whether the PinChangeNoticePerPort feature exists on the Ports
         module.
   Description:
     This function identifies whether the PinChangeNoticePerPort feature is
         available on the Ports module.
     When this function returns true, these functions are supported on the device:
     - PLIB_PORTS_PinChangeNoticePerPortEnable
     - PLIB_PORTS_PinChangeNoticePerPortDisable
     - PLIB_PORTS_ChannelChangeNoticeEnable
     - PLIB_PORTS_ChannelChangeNoticeDisable
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The PinChangeNoticePerPort feature is supported on the device
     - false - The PinChangeNoticePerPort feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_PORTS_ExistsPinChangeNoticePerPort (
   PORTS_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_PORTS_ExistsChangeNoticePerPortTurnOn( PORTS_MODULE_ID index )
   Summary:
     Identifies whether the ChangeNoticePerPortTurnOn feature exists on the Ports
         module.
   Description:
     This function identifies whether the ChangeNoticePerPortTurnOn feature is
         available on the Ports module.
     When this function returns true, these functions are supported on the device:
     - PLIB_PORTS_ChangeNoticePerPortTurnOn
     - PLIB_PORTS_ChangeNoticePerPortTurnOff
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChangeNoticePerPortTurnOn feature is supported on the device
     - false - The ChangeNoticePerPortTurnOn feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_PORTS_ExistsChangeNoticePerPortTurnOn (
   PORTS_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_PORTS_ExistsChangeNoticePerPortInIdle( PORTS_MODULE_ID index )
   Summary:
     Identifies whether the ChangeNoticeInIdlePerPort feature exists on the Ports
         module.
   Description:
     This function identifies whether the ChangeNoticeInIdlePerPort feature is
         available on the Ports module.
     When this function returns true, these functions are supported on the device:
     - PLIB_PORTS_ChangeNoticeInIdlePerPortEnable
     - PLIB_PORTS_ChangeNoticeInIdlePerPortDisable
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChangeNoticeInIdlePerPort feature is supported on the device
     - false - The ChangeNoticeInIdlePerPort feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_PORTS_ExistsChangeNoticePerPortInIdle (
   PORTS_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_PORTS_ExistsChangeNoticePerPortStatus( PORTS_MODULE_ID index )
   Summary:
     Identifies whether the ChangeNoticePerPortStatus feature exists on the Ports
         module.
   Description:
     This function identifies whether the ChangeNoticePerPortStatus feature is
         available on the Ports module.
     When this function returns true, these functions are supported on the device:
     - PLIB_PORTS_ChangeNoticePerPortHasOccured
     - PLIB_PORTS_ChangeNoticePerPortHasOccurred
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChangeNoticePerPortStatus feature is supported on the device
     - false - The ChangeNoticePerPortStatus feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_PORTS_ExistsChangeNoticePerPortStatus (
   PORTS_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_PORTS_ExistsSlewRateControl( PORTS_MODULE_ID index )
   Summary:
     Identifies whether the SlewRateControl feature exists on the Ports module.
   Description:
     This function identifies whether the SlewRateControl feature is available
         on the Ports module.
     When this function returns true, these functions are supported on the device:
     - PLIB_PORTS_ChannelSlewRateSelect
     - PLIB_PORTS_PinSlewRateGet
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The SlewRateControl feature is supported on the device
     - false - The SlewRateControl feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_PORTS_ExistsSlewRateControl (
   PORTS_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_PORTS_ExistsChannelChangeNoticeMethod( PORTS_MODULE_ID index )
   Summary:
     Identifies whether the ChannelChangeNoticeMethod feature exists on the
         Ports module.
   Description:
     This function identifies whether the ChannelChangeNoticeMethod feature is
         available on the Ports module.
     When this function returns true, these functions are supported on the device:
     - PLIB_PORTS_ChannelChangeNoticeMethodSelect
     - PLIB_PORTS_ChannelChangeNoticeMethodGet
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChannelChangeNoticeMethod feature is supported on the device
     - false - The ChannelChangeNoticeMethod feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_PORTS_ExistsChannelChangeNoticeMethod (
   PORTS_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_PORTS_ExistsChangeNoticeEdgeControl( PORTS_MODULE_ID index )
   Summary:
     Identifies whether the ChangeNoticeEdgeControl feature exists on the Ports
         module.
   Description:
     This function identifies whether the ChangeNoticeEdgeControl feature is
         available on the Ports module.
     When this function returns true, these functions are supported on the device:
     - PLIB_PORTS_ChannelChangeNoticeEdgeEnable
     - PLIB_PORTS_ChannelChangeNoticeEdgeDisable
     - PLIB_PORTS_PinChangeNoticeEdgeIsEnabled
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChangeNoticeEdgeControl feature is supported on the device
     - false - The ChangeNoticeEdgeControl feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_PORTS_ExistsChangeNoticeEdgeControl (
   PORTS_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_PORTS_ExistsChangeNoticeEdgeStatus( PORTS_MODULE_ID index )
   Summary:
     Identifies whether the ChangeNoticeEdgeStatus feature exists on the Ports
         module.
   Description:
     This function identifies whether the ChangeNoticeEdgeStatus feature is available
         on the Ports module.
     When this function returns true, this function is supported on the device:
     - PLIB_PORTS_PinChangeNoticeEdgeHasOccurred
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ChangeNoticeEdgeStatus feature is supported on the device
     - false - The ChangeNoticeEdgeStatus feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_PORTS_ExistsChangeNoticeEdgeStatus (
   PORTS_MODULE_ID index ) ;
 /* OPEN FILE C:\microchip\harmony\v2_06\framework\peripheral\ports\plib_ports_compatibility.h */
 /*******************************************************************************
   Ports Peripheral Library Compatibility Header
   Company:
     Microchip Technology Inc.
   File Name:
     plib_ports_compatibility.h
   Summary:
     Ports Peripheral Library Interface header for backward compatibility.
   Description:
     This header file contains the definitions of the functions which are
     supported for backward compatibility only. These will be deprecated later.
 *******************************************************************************/
 // DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright 2013-2015 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
 *******************************************************************************/
 // DOM-IGNORE-END
 #ifndef _PLIB_PORTS_COMPATIBILITY_H
 #define _PLIB_PORTS_COMPATIBILITY_H
 #include <stdint.h>
 #include <stddef.h>
 // *****************************************************************************
 /* Function:
    bool PLIB_PORTS_ChangeNoticePerPortHasOccured ( PORTS_MODULE_ID index,
                                PORTS_CHANNEL channel, PORTS_BIT_POS bitPos );
   Summary:
     checks the status of change on the pin
   Description:
     This function checks if the change has occurred on the given pin or not.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Port pin channel
     bitPos - Position in the PORT pins
   Returns:
     None.
   Example:
     <code>

     if(PLIB_PORTS_ChangeNoticePerPortHasOccured( PORTS_ID_0,
                                     PORT_CHANNEL_C, PORTS_BIT_POS_4 ) == True)
     {
      //do something
     }

     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         PLIB_PORTS_ExistsChangeNoticePerPortStatus in your application to determine
     whether this feature is available.

     This function will be deprecated later.
 */
 #define PLIB_PORTS_ChangeNoticePerPortHasOccured PLIB_PORTS_ChangeNoticePerPortHasOccurred
        // #ifndef _PLIB_PORTS_COMPATIBILITY_H
 /*******************************************************************************
  End of File
 */
 #endif /*00 C:\microchip\harmony\v2_06\framework\peripheral\ports\plib_ports_compatibility.h*/
 /*   CLOSE_FILE Include File */

 //DOM-IGNORE-BEGIN
 //DOM-IGNORE-END
        // #ifndef _PLIB_PORTS_H
 /*******************************************************************************
  End of File
 */
 #endif /*00 C:\microchip\harmony\v2_06\framework\peripheral\ports\plib_ports.h*/
 /*   CLOSE_FILE Include File */

 #include "system/int/sys_int.h"
 // *****************************************************************************
 // *****************************************************************************
 // Section: SYS PORTS Data Types
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* SYS PORTS PULLUP status
  Summary:
  Provides the pull-up and pull-down status.
  Description:
  These constants provide the pull-up or pull-down status definitions.
  Remarks:
  None.
 */

 typedef
   enum
   {
     /* PULLUP Disable */
     SYS_PORTS_PULLUP_DISABLE
         /*DOM-IGNORE-BEGIN*/
     = 0                          /*DOM-IGNORE-END*/
     ,
     /* PULLUP Enable */
     SYS_PORTS_PULLUP_ENABLE
         /*DOM-IGNORE-BEGIN*/
     = 1                          /*DOM-IGNORE-END*/
     ,
   } SYS_PORTS_PULLUP_PULLDOWN_STATUS ;
 // *****************************************************************************
 /* SYS PORTS PIN DIRECTION
  Summary:
  Defines the direction of the port pins.
  Description:
  These constants provide the port pin direction definitions.
  Remarks:
  None.
 */

 typedef
   enum
   {
     /* Direction as output */
     SYS_PORTS_DIRECTION_OUTPUT
         /*DOM-IGNORE-BEGIN*/
     = 0                          /*DOM-IGNORE-END*/
     ,
     /* Direction as input */
     SYS_PORTS_DIRECTION_INPUT
         /*DOM-IGNORE-BEGIN*/
     = 1                          /*DOM-IGNORE-END*/
     ,
   } SYS_PORTS_PIN_DIRECTION ;

 typedef
   enum
   {
     PORTS_PIN_INTERRUPT_NONE
   } PORTS_PIN_INTERRUPT_TYPE ;
        // #ifndef _SYS_PORTS_DEFINITIONS_H
 /*******************************************************************************
  End of File
 */

 #endif /*00 C:\microchip\harmony\v2_06\framework\system\ports\sys_ports_definitions.h*/
 /*   CLOSE_FILE Include File */

 // DOM-IGNORE-BEGIN
 // DOM-IGNORE-END
 // *****************************************************************************
 // *****************************************************************************
 // Section: SYS PorTS Module Initialization Routine
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_Initialize()
   Summary:
     Initializes PORT Pins/Channels.
         <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This function initializes different port pins/channels to the desired state.
     It also remaps the pins to the desired specific function.
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     None.
   Example:
     <code>
         SYS_PORTS_Initialize();
     </code>
   Remarks:
     This API must be be called at the time of system initialization to
         initialize the ports pins.
 */

 void
   SYS_PORTS_Initialize() ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: SYS PORTS CONTROL Routines
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Function:
     PORTS_DATA_TYPE SYS_PORTS_Read( PORTS_MODULE_ID index, PORTS_CHANNEL channel )
   Summary:
     Reads the data from the I/O port.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function reads the data from the I/O port.
   Preconditions:
     The direction of the port to be set as input.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the PORT channel: A, B, C, etc.
   Returns:
     Returns the data read from the port.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     PORTS_DATA_TYPE readData;
     readData = SYS_PORTS_Read( MY_PORTS_INSTANCE, MY_CHANNEL );
         </code>
   Remarks:
     None.
 */

 PORTS_DATA_TYPE
   SYS_PORTS_Read (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_Write( PORTS_MODULE_ID index,
                           PORTS_CHANNEL channel,
                           PORTS_DATA_TYPE value )
   Summary:
     Writes the data to the I/O port.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function writes the data to the I/O port.
   Preconditions:
     The direction of the port to be set as output.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the PORT channel: A, B, C, etc.
     value - Value to be written into a port of width PORTS_DATA_TYPE
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
         PORTS_DATA_TYPE writeData;
         SYS_PORTS_Write( MY_PORTS_INSTANCE, MY_CHANNEL, MY_VALUE );
         </code>
   Remarks:
     None.
 */

 void
   SYS_PORTS_Write (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_DATA_TYPE value ) ;
 // *****************************************************************************
 /* Function:
     PORTS_DATA_TYPE SYS_PORTS_LatchedGet( PORTS_MODULE_ID index, PORTS_CHANNEL channel )
   Summary:
     Reads the data driven on the I/O port.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function reads the data driven on the I/O port.
   Preconditions:
     The direction of the port to be set as output.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the PORT channel: A, B, C, etc.
   Returns:
     Returns the data driven on the port.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     PORTS_DATA_TYPE drivenData;
     drivenData = SYS_PORTS_LatchedGet( MY_PORTS_INSTANCE, MY_CHANNEL );
         </code>
   Remarks:
     None.
 */

 PORTS_DATA_TYPE
   SYS_PORTS_LatchedGet (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_Set( PORTS_MODULE_ID index, PORTS_CHANNEL channel,
                          PORTS_DATA_TYPE value,
                          PORTS_DATA_MASK mask )
   Summary:
     Sets the selected digital port/latch based on the mask.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function Sets the selected digital port/latch relative to the mask.
     This function "AND" value and mask parameters and then set the bits
     in the port channel that were set in the result of the ANDing operation.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the PORT channel: A, B, C, etc.
     value - Consists of information about which port bit has to be set
     mask - Identifies the bits which could be intended for setting
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     // MY_VALUE - 0x1234
     PORTS_DATA_MASK myMask = (PORTS_DATA_MASK)0x00FF;
     // Set the MY_CHANNEL bit positions 2,4 and 5 (0x0034 = b0000 0000 0011 0100)
     SYS_PORTS_Set(MY_PORTS_INSTANCE, MY_CHANNEL, MY_VALUE, myMask);
     </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 void
   SYS_PORTS_Set (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_DATA_TYPE value ,
   PORTS_DATA_MASK mask ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_Clear ( PORTS_MODULE_ID index, PORTS_CHANNEL channel,
                            PORTS_DATA_MASK clearMask )
   Summary:
     Clears the selected digital port.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function clears the selected digital port.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the PORT channel: A, B, C, etc.
     clearMask - Identifies the bits to be cleared
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     PORTS_DATA_MASK clearMask = (PORTS_DATA_MASK)0x00FF;
     SYS_PORTS_Clear( MY_PORTS_INSTANCE, MY_CHANNEL, clearMask );
         </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 void
   SYS_PORTS_Clear (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_DATA_MASK clearMask ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_DirectionSelect( PORTS_MODULE_ID index,
                                  SYS_PORTS_PIN_DIRECTION pinDir,
                                  PORTS_CHANNEL channel,
                                  PORTS_DATA_MASK mask )
   Summary:
     Enables the direction for the selected port.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function enables the direction for the selected port.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     pinDir - Pin direction
     channel - Identifier for the PORT channel: A, B, C, etc.
     mask - Mask for the direction of width PORTS_DATA_MASK
   Returns:
     None
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     SYS_PORTS_PIN_DIRECTION pinDir;
     pinDir = SYS_PORTS_DIRECTION_INPUT;
     PORTS_DATA_MASK myMask = (PORTS_DATA_MASK)0x00FF;
     SYS_PORTS_DirectionSelect(MY_PORTS_INSTANCE, pinDir, MY_CHANNEL, myMask );
         </code>
   Remarks:
     None.
 */

 void
   SYS_PORTS_DirectionSelect (
   PORTS_MODULE_ID index ,
   SYS_PORTS_PIN_DIRECTION pinDir ,
   PORTS_CHANNEL channel ,
   PORTS_DATA_MASK mask ) ;
 // *****************************************************************************
 /* Function:
     PORTS_DATA_MASK SYS_PORTS_DirectionGet( PORTS_MODULE_ID index, PORTS_CHANNEL channel )
   Summary:
     Reads the direction for the selected port.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function reads the direction for the selected port.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the PORT channel: A, B, C, etc.
   Returns:
     Direction of the port.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     PORTS_DATA_MASK value;
     value = SYS_PORTS_DirectionGet( MY_PORTS_INSTANCE, MY_CHANNEL );
         </code>
   Remarks:
     None.
 */

 PORTS_DATA_MASK
   SYS_PORTS_DirectionGet (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_Toggle( PORTS_MODULE_ID index, PORTS_CHANNEL channel,
                            PORTS_DATA_MASK toggleMask )
   Summary:
     Toggles the selected digital port pins.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function toggles the selected digital port pins.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the PORT channel: A, B, C, etc.
     toggleMask - Identifies the bits to be toggled
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     PORTS_DATA_MASK toggleMask = (PORTS_DATA_MASK)0x00FF;
     SYS_PORTS_Toggle( MY_PORTS_INSTANCE, MY_CHANNEL, toggleMask );
         </code>
   Remarks:
     None.
 */

 void
   SYS_PORTS_Toggle (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_DATA_MASK toggleMask ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_OpenDrainEnable( PORTS_MODULE_ID index, PORTS_CHANNEL channel,
                                      PORTS_DATA_MASK mask )
   Summary:
     Enables the open-drain functionality for the selected port.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function enables the open-drain functionality for the selected port.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the PORT channel: A, B, C, etc.
     mask - Mask of type PORTS_DATA_MASK
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     SYS_PORTS_OpenDrainEnable( MY_PORTS_INSTANCE, MY_CHANNEL, (PORTS_DATA_MASK)0x00FF );
         </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 void
   SYS_PORTS_OpenDrainEnable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_DATA_MASK mask ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_OpenDrainDisable( PORTS_MODULE_ID index, PORTS_CHANNEL channel,
                                      PORTS_DATA_MASK mask )
   Summary:
     Disables the open-drain functionality for the selected port.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function disables the open-drain functionality for the selected port.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the PORT channel: A, B, C, etc.
     mask - Mask of type PORTS_DATA_MASK
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     SYS_PORTS_PeripheralOpenDrainDisable( MY_PORTS_INSTANCE, MY_CHANNEL, (PORTS_DATA_MASK)0x00FF );
         </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 void
   SYS_PORTS_OpenDrainDisable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_DATA_MASK mask ) ;
 // *****************************************************************************
 /* Function:
     PORTS_DATA_TYPE SYS_PORTS_InterruptStatusGet
     (
         PORTS_MODULE_ID index,
         PORTS_CHANNEL channel
     )
   Summary:
     Reads the interrupt status from the I/O port.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function reads the interrupt status from the I/O port.
   Preconditions:
     The interrupts should have been configured.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the PORT channel: A, B, C, etc.
   Returns:
     Returns the interrupt status of the port channel.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     PORTS_DATA_TYPE channelStatus;
     channelStatus = SYS_PORTS_InterruptStatusGet( MY_PORTS_INSTANCE, MY_CHANNEL );
         </code>
   Remarks:
     None.
 */

 PORTS_DATA_TYPE
   SYS_PORTS_InterruptStatusGet (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: SYS PORT PINS REMAPING Routines
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_RemapInput( PORTS_MODULE_ID index,
                 PORTS_REMAP_INPUT_FUNCTION function,
                 PORTS_REMAP_INPUT_PIN remapPin )
   Summary:
     Input/Output (I/O) function remapping.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function controls the I/O function remapping.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     function - One of the possible values of PORTS_REMAP_INPUT_FUNCTION
     remapPin - One of the possible values of PORTS_REMAP_INPUT_PIN
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     // Remapping input function 'Input Capture 1' to the Remappable pin 'RPD2'
     SYS_PORTS_RemapInput(MY_PORTS_INSTANCE, INPUT_FUNC_IC1, INPUT_PIN_RPD2 );
     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         SYS_PORTS_ExistsRemapInputOutput in your application to determine whether
         this feature is available.
 */

 void
   SYS_PORTS_RemapInput (
   PORTS_MODULE_ID index ,
   PORTS_REMAP_INPUT_FUNCTION function ,
   PORTS_REMAP_INPUT_PIN remapPin ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_RemapOutput( PORTS_MODULE_ID index,
                                       PORTS_REMAP_OUTPUT_FUNCTION function,
                                       PORTS_REMAP_OUTPUT_PIN remapPin )
   Summary:
     Input/Output (I/O) function remapping.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function controls the I/O function remapping.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     function - One of the possible values of PORTS_REMAP_OUTPUT_FUNCTION
     remapPin - One of the possible values of PORTS_REMAP_OUTPUT_PIN
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     // Remapping output function 'UART3 Transmit' to the Remappable pin 'RPA14'
     SYS_PORTS_RemapInputOutput(MY_PORTS_INSTANCE, OUTPUT_FUNC_U3TX, OUTPUT_PIN_RPA14);
     </code>
   Remarks:
         This feature may not be available on all devices. Please refer to the
         specific device data sheet to determine availability or use
         SYS_PORTS_ExistsRemapInputOutput in your application to determine whether
         this feature is available.
 */

 void
   SYS_PORTS_RemapOutput (
   PORTS_MODULE_ID index ,
   PORTS_REMAP_OUTPUT_FUNCTION function ,
   PORTS_REMAP_OUTPUT_PIN remapPin ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: SYS Change Notification Pins Routines
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_ChangeNotificationGlobalEnable( PORTS_MODULE_ID index )
   Summary:
     Globally enables the change notification for the selected port.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function globally enables the change notification for the selected port.
   Preconditions:
     None.
   Parameters:
     None.
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     SYS_PORTS_ChangeNotificationGlobalEnable( MY_PORTS_INSTANCE );
         </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 void
   SYS_PORTS_ChangeNotificationGlobalEnable (
   PORTS_MODULE_ID index ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_ChangeNotificationGlobalDisable( PORTS_MODULE_ID index );
   Summary:
     Globally disables the change notification for the selected port.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function globally disables the change notification for the selected port.
   Preconditions:
     None.
   Parameters:
     None.
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     SYS_PORTS_ChangeNotificationGlobalDisable( MY_PORTS_INSTANCE);
         </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 void
   SYS_PORTS_ChangeNotificationGlobalDisable (
   PORTS_MODULE_ID index ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_ChangeNotificationEnable( PORTS_MODULE_ID index,
                                              PORTS_CHANGE_NOTICE_PIN pinNum,
                                              SYS_PORTS_PULLUP_PULLDOWN_STATUS value )
   Summary:
     Enables the change notification for the selected port.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function enables the change notification for the selected port.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     value - Pull-up enable or disable value
     pinNum - Possible values of PORTS_CHANGE_NOTICE_PIN
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     SYS_PORTS_PULLUP_PULLDOWN_STATUS value;
     PORTS_CHANGE_NOTICE_PIN pinNum;
     SYS_PORTS_ChangeNotificationEnable( index, pinNum, value );
         </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 void
   SYS_PORTS_ChangeNotificationEnable (
   PORTS_MODULE_ID index ,
   PORTS_CHANGE_NOTICE_PIN pinNum ,
   SYS_PORTS_PULLUP_PULLDOWN_STATUS value ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_ChangeNotificationDisable( PORTS_MODULE_ID index,
                                               PORTS_CHANGE_NOTICE_PIN pinNum )
   Summary:
     Disables the change notification for the selected port.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function disables the change notification for the selected port.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     pinNum - Possible values of PORTS_CHANGE_NOTICE_PIN
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     PORTS_CHANGE_NOTICE_PIN pinNum;
     SYS_PORTS_ChangeNotificationDisable( index, pinNum );
         </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 void
   SYS_PORTS_ChangeNotificationDisable (
   PORTS_MODULE_ID index ,
   PORTS_CHANGE_NOTICE_PIN pinNum ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_ChangeNotificationInIdleModeEnable( PORTS_MODULE_ID index );
   Summary:
     Enables the change notification for the selected port in Sleep or Idle mode.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function enables the change notification for the selected port in Sleep
     or Idle mode.
   Preconditions:
     None.
   Parameters:
     None.
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     SYS_PORTS_ChangeNotificationInIdleModeEnable( MY_PORTS_INSTANCE );
         </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 void
   SYS_PORTS_ChangeNotificationInIdleModeEnable (
   PORTS_MODULE_ID index ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_ChangeNotificationInIdleModeDisable( PORTS_MODULE_ID index);
   Summary:
     Disables the change notification for the selected port in Sleep or Idle mode.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function disables the change notification for the selected port in Sleep
     or Idle mode.
   Preconditions:
     None.
   Parameters:
     None.
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     SYS_PORTS_ChangeNotificationInIdleModeDisable( MY_PORTS_INSTANCE );
         </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 void
   SYS_PORTS_ChangeNotificationInIdleModeDisable (
   PORTS_MODULE_ID index ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_ChangeNotificationPullUpEnable ( PORTS_MODULE_ID index,
                                                     PORTS_CHANGE_NOTICE_PIN pinNum )
   Summary:
     Enables a weak pull-up on the change notification pin.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function enables a weak pull-up on the change notification pin.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     pinNum - Possible values of PORTS_CHANGE_NOTICE_PIN
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     // MY_PINNUM - PORTS_CHANGE_NOTICE_PIN_10
     SYS_PORTS_ChangeNotificationPullUpEnable( MY_PORTS_INSTANCE, MY_PINNUM );
         </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 void
   SYS_PORTS_ChangeNotificationPullUpEnable (
   PORTS_MODULE_ID index ,
   PORTS_CHANGE_NOTICE_PIN pinNum ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_ChangeNotificationPullUpDisable ( PORTS_MODULE_ID index,
                                                     PORTS_CHANGE_NOTICE_PIN pinNum )
   Summary:
     Disables a weak pull-up on the change notification pin.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function Disables a weak pull-up on the change notification pin.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     pinNum - Possible values of PORTS_CHANGE_NOTICE_PIN
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     // MY_PINNUM - PORTS_CHANGE_NOTICE_PIN_10
     SYS_PORTS_ChangeNotificationPullUpDisable( MY_PORTS_INSTANCE, MY_PINNUM );
         </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 void
   SYS_PORTS_ChangeNotificationPullUpDisable (
   PORTS_MODULE_ID index ,
   PORTS_CHANGE_NOTICE_PIN pinNum ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: SYS PORT PINS Control Routines
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_PinModeSelect ( PORTS_MODULE_ID index,
                                        PORTS_ANALOG_PIN pin,
                   PORTS_PIN_MODE mode)
   Summary:
     Enables the selected pin as analog or digital.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function enables the selected pin as analog or digital.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     pin - Possible values of PORTS_ANALOG_PIN
     mode - Possible values of PORTS_PIN_MODE
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     // MY_PIN - PORTS_ANALOG_PIN_AN0
     // MY_PIN_MODE - PORTS_PIN_MODE_ANALOG
     SYS_PORTS_PinModSYS_PORTS_PinModeSelecteSelect( MY_PORTS_INSTANCE, MY_PIN, MY_PIN_MODE );
         </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 void
   SYS_PORTS_PinModeSelect (
   PORTS_MODULE_ID index ,
   PORTS_ANALOG_PIN pin ,
   PORTS_PIN_MODE mode ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_PinWrite ( PORTS_MODULE_ID index,
                               PORTS_CHANNEL channel,
                               PORTS_BIT_POS bitPos
                               bool value )
   Summary:
     Writes the selected digital pin.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function writes the selected digital pin.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the PORT channel: A, B, C, etc.
     bitPos - Possible values of PORTS_BIT_POS
     value - Value to be written to the specific pin/latch:
                       - true - Sets the bit
                       - false - Clears the bit
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     // MY_PINNUM - PORTS_PIN_10
     SYS_PORTS_PinWrite(MY_PORTS_INSTANCE, MY_CHANNEL, MY_PINNUM, value);
         </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 void
   SYS_PORTS_PinWrite (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ,
   bool value ) ;
 // *****************************************************************************
 /* Function:
     bool SYS_PORTS_PinLatchedGet ( PORTS_MODULE_ID index,
                              PORTS_CHANNEL channel,
                              PORTS_BIT_POS bitPos )
   Summary:
     Reads the data driven on the selected digital pin.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function reads the data driven on the selected
     digital output pin.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the PORT channel: A, B, C, etc.
     bitPos - Possible values of PORTS_BIT_POS
   Returns:
     The status of the data driven on the port pin.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     // MY_PINNUM - PORTS_PIN_10
     status = SYS_PORTS_PinLatchedGet(MY_PORTS_INSTANCE, MY_CHANNEL, MY_PINNUM);
         </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 bool
   SYS_PORTS_PinLatchedGet (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     bool SYS_PORTS_PinRead ( PORTS_MODULE_ID index,
                              PORTS_CHANNEL channel,
                              PORTS_BIT_POS bitPos )
   Summary:
     Reads the selected digital pin.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function reads the selected digital pin, not the Latch.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the PORT channel: A, B, C, etc.
     bitPos - Possible values of PORTS_BIT_POS
   Returns:
     The status of the port pin.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     // MY_PINNUM - PORTS_PIN_10
     bool bitStatus = SYS_PORTS_PinRead(MY_PORTS_INSTANCE, MY_CHANNEL, MY_PINNUM);
         </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 bool
   SYS_PORTS_PinRead (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_PinToggle ( PORTS_MODULE_ID index,
                                PORTS_CHANNEL channel,
                                PORTS_BIT_POS bitPos )
   Summary:
     Toggles the selected digital pin.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function toggles the selected digital pin.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the PORT channel: A, B, C, etc.
     bitPos - Possible values of PORTS_BIT_POS
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     // MY_PINNUM - PORTS_PIN_10
     SYS_PORTS_PinToggle( MY_PORTS_INSTANCE, MY_CHANNEL, MY_PINNUM );
         </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 void
   SYS_PORTS_PinToggle (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_PinSet( PORTS_MODULE_ID index,
                            PORTS_CHANNEL channel,
                            PORTS_BIT_POS bitPos )
   Summary:
     Sets the selected digital pin/latch.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function sets the selected digital pin/latch.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the PORT channel: A, B, C, etc.
     bitPos - Possible values of PORTS_BIT_POS
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     // MY_PINNUM - PORTS_PIN_10
     SYS_PORTS_PinSet(MY_PORTS_INSTANCE, MY_CHANNEL, MY_PINNUM);
     </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 void
   SYS_PORTS_PinSet (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_PinClear ( PORTS_MODULE_ID index,
                               PORTS_CHANNEL channel,
                               PORTS_BIT_POS bitPos )
   Summary:
     Clears the selected digital pin.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function clears the selected digital pin.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the PORT channel: A, B, C, etc.
     bitPos - Possible values of PORTS_BIT_POS
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     // MY_PINNUM - PORTS_IO_PIN_10
     SYS_PORTS_PinClear( MY_PORTS_INSTANCE, MY_CHANNEL, MY_PINNUM );
         </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 void
   SYS_PORTS_PinClear (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_PinDirectionSelect ( PORTS_MODULE_ID index,
                                      SYS_PORTS_PIN_DIRECTION pinDir,
                                      PORTS_CHANNEL channel,
                                      PORTS_BIT_POS bitPos )
   Summary:
     Enables the direction for the selected pin.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function enables the direction for the selected pin.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     pinDir - Pin direction
     channel - Identifier for the PORT channel: A, B, C, etc.
     bitPos - Possible values of PORTS_BIT_POS
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     // MY_PINNUM - PORTS_PIN_10
     SYS_PORTS_PIN_DIRECTION pinDir;
     pinDir = SYS_PORTS_DIRECTION_INPUT;
     SYS_PORTS_PinDirectionSelect(MY_PORTS_INSTANCE, pinDir, MY_CHANNEL, MY_PINNUM);
         </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 void
   SYS_PORTS_PinDirectionSelect (
   PORTS_MODULE_ID index ,
   SYS_PORTS_PIN_DIRECTION pinDir ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_PinOpenDrainEnable ( PORTS_MODULE_ID index,
                                         PORTS_CHANNEL channel,
                                         PORTS_BIT_POS bitPos )
   Summary:
     Enables the open-drain functionality for the selected pin.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function enables the open-drain functionality for the selected pin.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the PORT channel: A, B, C, etc.
     bitPos - Possible values of PORTS_BIT_POS
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     // MY_PINNUM - PORTS_PIN_10
     SYS_PORTS_PinOpenDrainEnable( MY_PORTS_INSTANCE, MY_CHANNEL, MY_PINNUM );
         </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 void
   SYS_PORTS_PinOpenDrainEnable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_PinOpenDrainDisable ( PORTS_MODULE_ID index,
                                          PORTS_CHANNEL channel,
                                          PORTS_BIT_POS bitPos )
   Summary:
     Disables the open-drain functionality for the selected pin.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function disables the open-drain functionality for the selected pin.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the PORT channel: A, B, C, etc.
     bitPos - Possible values of PORTS_BIT_POS
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     // MY_PINNUM - PORTS_PIN_10
     SYS_PORTS_PinOpenDrainDisable(MY_PORTS_INSTANCE, MY_PINNUM);
         </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 void
   SYS_PORTS_PinOpenDrainDisable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_PinPullUpEnable ( PORTS_MODULE_ID index,
                                         PORTS_CHANNEL channel,
                                         PORTS_BIT_POS bitPos )
   Summary:
     Enables the pull-up functionality for the selected pin.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function enables the pull-up functionality for the selected pin.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the PORT channel: A, B, C, etc.
     bitPos - Possible values of PORTS_BIT_POS
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     // MY_PINNUM - PORTS_PIN_10
     SYS_PORTS_PinPullUpEnable( MY_PORTS_INSTANCE, MY_CHANNEL, MY_PINNUM );
         </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 void
   SYS_PORTS_PinPullUpEnable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_PinPullUpDisable ( PORTS_MODULE_ID index,
                                          PORTS_CHANNEL channel,
                                          PORTS_BIT_POS bitPos )
   Summary:
     Disables the pull-up functionality for the selected pin.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function disables the pull-up functionality for the selected pin.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the PORT channel: A, B, C, etc.
     bitPos - Possible values of PORTS_BIT_POS
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     // MY_PINNUM - PORTS_PIN_10
     SYS_PORTS_PinPullUpDisable(MY_PORTS_INSTANCE, MY_PINNUM);
         </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 void
   SYS_PORTS_PinPullUpDisable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_PinPullDownEnable ( PORTS_MODULE_ID index,
                                         PORTS_CHANNEL channel,
                                         PORTS_BIT_POS bitPos )
   Summary:
     Enables the pull-down functionality for the selected pin.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function enables the pull-down functionality for the selected pin.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the PORT channel: A, B, C, etc.
     bitPos - Possible values of PORTS_BIT_POS
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     // MY_PINNUM - PORTS_PIN_10
     SYS_PORTS_PinPullDownEnable( MY_PORTS_INSTANCE, MY_CHANNEL, MY_PINNUM );
         </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 void
   SYS_PORTS_PinPullDownEnable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 // *****************************************************************************
 /* Function:
     void SYS_PORTS_PinPullDownDisable ( PORTS_MODULE_ID index,
                                          PORTS_CHANNEL channel,
                                          PORTS_BIT_POS bitPos )
   Summary:
     Disables the pull-down functionality for the selected pin.
         <p><b>Implementation:</b> Dynamic</p>
   Description:
     This function disables the pull-down functionality for the selected pin.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the PORT channel: A, B, C, etc.
     bitPos - Possible values of PORTS_BIT_POS
   Returns:
     None.
   Example:
     <code>
     // Where MY_PORTS_INSTANCE, is the ports instance selected for use by the
     // application developer.
     // MY_PINNUM - PORTS_PIN_10
     SYS_PORTS_PinPullDownDisable(MY_PORTS_INSTANCE, MY_PINNUM);
         </code>
   Remarks:
     Not all features are available on all devices. Refer to the specific device
     data sheet for availability.
 */

 void
   SYS_PORTS_PinPullDownDisable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ) ;
 //******************************************************************************
 /* Function:
     void SYS_PORTS_InterruptEnable
     (
         PORTS_MODULE_ID index,
         PORTS_CHANNEL channel,
         PORTS_BIT_POS bitPos,
         PORTS_PIN_INTERRUPT_TYPE pinInterruptType
     )
   Summary:
     Enables the selected interrupt for the selected port pin.
   Description:
     This function enables the selected interrupt for the selected port pin.
   Preconditions:
     Select the pull-up or pull-down as required.
   Parameters:
     index - Identifier for the device instance to be configured
     channel - Identifier for the PORT channel: A, B, C, etc.
     bitPos - Possible values of PORTS_BIT_POS
     pinInterruptType - Interrupt type from PORTS_PIN_INTERRUPT_TYPE set
   Returns:
     None.
   Example:
     <code>
     SYS_PORTS_InterruptEnable(MY_PORTS_INSTANCE, MY_PORTS_CHANNEL, MY_PORT_BIT_POS, PORTS_PIN_INTERRUPT_BOTH_EDGE );
         </code>
   Remarks:
     None.
 */

 void
   SYS_PORTS_InterruptEnable (
   PORTS_MODULE_ID index ,
   PORTS_CHANNEL channel ,
   PORTS_BIT_POS bitPos ,
   PORTS_PIN_INTERRUPT_TYPE pinInterruptType ) ;
 //DOM-IGNORE-BEGIN
 //DOM-IGNORE-END
        //SYS_PORTS_H
 /*******************************************************************************
  End of File
 */

 #endif /*00 C:\microchip\harmony\v2_06\framework\system\ports\sys_ports.h*/
 /*   CLOSE_FILE Include File */

 /* OPEN FILE C:\microchip\harmony\v2_06\framework\driver\spi\drv_spi.h */
 /*******************************************************************************
  SPI Driver Interface
  Company:
  Microchip Technology Inc.
  File Name:
  drv_spi.h
  Summary:
  SPI device driver interface file.
  Description:
  The SPI driver provides a simple interface to manage the SPI module.
  This file defines the interface definitions and prototypes for the SPI driver.
 *******************************************************************************/
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2013-2014 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
 *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _DRV_SPI_H
 #define _DRV_SPI_H
 /* OPEN FILE C:\microchip\harmony\v2_06\framework\driver\spi\drv_spi_definitions.h */
 /*******************************************************************************
  SPI Driver Interface
  Company:
  Microchip Technology Inc.
  File Name:
  drv_spi_definitions.h
  Summary:
  SPI device driver interface file.
  Description:
  The SPI driver provides a simple interface to manage the SPI module.
  This file defines the interface definitions and prototypes for the SPI
  driver.
 *******************************************************************************/
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2016 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
 *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _DRV_SPI_DEFINITIONS_H
 #define _DRV_SPI_DEFINITIONS_H
 // *****************************************************************************
 // *****************************************************************************
 // Section: Data Types
 // *****************************************************************************
 // *****************************************************************************
 #include <stdint.h>
 #include <stdbool.h>
 #include "C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\system_config\default\system_config.h"  /* LDRA full path */
 #include "C:\microchip\harmony\v2_06\framework\driver\driver_common.h"           // Common Driver Definitions /* LDRA full path */
 /* OPEN FILE C:\microchip\harmony\v2_06\framework\peripheral\spi\plib_spi.h */
 /*******************************************************************************
  SPI Peripheral Library Interface Header
  Company:
  Microchip Technology Inc.
  File Name:
  plib_spi.h
  Summary:
  SPI Peripheral Library Interface Header for common definitions.
  Description:
  This header file contains the function prototypes and definitions of
  the data types and constants that make up the interface to the SPI
  PLIB.
  *******************************************************************************/
 // DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright 2013-2015 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
  *******************************************************************************/
 // DOM-IGNORE-END
 #ifndef _PLIB_SPI_H
 #define _PLIB_SPI_H
 // DOM-IGNORE-BEGIN
 // DOM-IGNORE-END
 // *****************************************************************************
 // *****************************************************************************
 // Section: Included Files (continued at end of file)
 // *****************************************************************************
 // *****************************************************************************
 /* This section lists the other files that are included in this file. However,
     please see the end of the file for additional implementation header files
     that are also included.
  */
 /* OPEN FILE C:\microchip\harmony\v2_06\framework\peripheral\spi\processor\spi_processor.h */
 //DOM-IGNORE-BEGIN
 /*******************************************************************************
 Copyright (c) 2011-2016 released Microchip Technology Inc. All rights reserved.
 Microchip licenses to you the right to use, modify, copy and distribute
 Software only when embedded on a Microchip microcontroller or digital signal
 controller that is integrated into your product or third party product
 (pursuant to the sublicense terms in the accompanying license agreement).
 You should refer to the license agreement accompanying this Software for
 additional information regarding your rights and obligations.
 SOFTWARE AND DOCUMENTATION ARE PROVIDED 'AS IS' WITHOUT WARRANTY OF ANY KIND,
 EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
 MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.
 IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER
 CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR
 OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
 INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR
 CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF
 SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
 (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
  *******************************************************************************/
 //DOM-IGNORE-END
 #ifndef _PLIB_SPI_PROCESSOR_H
 #define _PLIB_SPI_PROCESSOR_H
 #error "Can't find header"
 #endif /*00 C:\microchip\harmony\v2_06\framework\peripheral\spi\processor\spi_processor.h*/
 /*   CLOSE_FILE Include File */

 // *****************************************************************************
 // *****************************************************************************
 // Section: Constants & Data Types
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 // Section: SPI Peripheral Library Interface Routines
 // *****************************************************************************
 // *****************************************************************************
 //******************************************************************************
 /* Function:
     void PLIB_SPI_Enable( SPI_MODULE_ID index )
  Summary:
     Enables the SPI module.
  Description:
     This function enables the SPI module.
     This operation is atomic.
  Precondition:
     None.
  Parameters:
     index - Identifier for the device instance to be configured
  Returns:
     None.
  Example:
    <code>
    // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
    // application developer.
    PLIB_SPI_Enable(MY_SPI_INSTANCE);
    </code>
  Remarks:
     The SCKx, SDOx, SDIx and SSx pins must be assigned to available RPn pins
     before use.
     This function implements an operation of the enable control feature. This
     feature may not be available on all devices. Please refer to the specific
     device data sheet to determine availability or use "PLIB_SPI_ExistsEnableControl"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_Enable (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_Disable (SPI_MODULE_ID index)
  Summary:
     Disables the SPI module.
  Description:
     This function disables the SPI module.
     This operation is atomic.
  Precondition:
     None.
  Parameters:
     index - Identifier for the device instance to be configured
  Returns:
     None.
  Example:
    <code>
    // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
    // application developer.
    PLIB_SPI_Disable(MY_SPI_INSTANCE);
    </code>
  Remarks:
     This function implements an operation of the enable control feature. This
     feature may not be available on all devices. Please refer to the specific
     device data sheet to determine availability or use "PLIB_SPI_ExistsEnableControl"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_Disable (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
    void PLIB_SPI_StopInIdleEnable (SPI_MODULE_ID index)
  Summary:
    Discontinues module operation when the device enters Idle mode.
  Description:
    This function sets up the SPI module such that module operation is disabled
    when the device enters Idle mode.
     This operation is atomic.
  Precondition:
    None.
  Parameters:
    index - Identifier for the device instance to be configured
  Returns:
    None.
  Example:
    <code>
    // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
    // application developer.
    PLIB_SPI_StopInIdleEnable(MY_SPI_INSTANCE);
    </code>
  Remarks:
     This function implements an operation of the stop in idle control feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     "PLIB_SPI_ExistsStopInIdleControl" in your application to automatically
     determine if this feature is available.
  */

 void
   PLIB_SPI_StopInIdleEnable (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
    void PLIB_SPI_StopInIdleDisable (SPI_MODULE_ID index)
  Summary:
    Continues module operation when the device enters Idle mode.
  Description:
    This function sets up the SPI module such that module operation is continued
    when the device enters Idle mode.
     This operation is atomic.
  Precondition:
    None.
  Parameters:
    index - Identifier for the device instance to be configured
  Returns:
    None.
  Example:
    <code>
    // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
    // application developer.
    PLIB_SPI_StopInIdleDisable(MY_SPI_INSTANCE);
    </code>
  Remarks:
     This function implements an operation of the stop in idle control feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use
     "PLIB_SPI_ExistsStopInIdleControl" in your application to determine whether
     this feature is available.
  */

 void
   PLIB_SPI_StopInIdleDisable (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_SPI_ReceiverHasOverflowed (SPI_MODULE_ID index)
   Summary:
     Returns the current status of the SPI receiver overflow.
   Description:
     This function returns the current status of the SPI receiver overflow.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     SPI receiver overflow status:
     - true - A new byte/word is completely received and discarded.
               The user software has not read the previous data in
               the SPI buffer register.
     - false - No Overflow has occurred
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     bool overflowstate = PLIB_SPI_ReceiverHasOverflowed(MY_SPI_INSTANCE);
     </code>
   Remarks:
     This function implements an operation of the receiver overflow status feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsReceiverOverflow"
     in your application to automatically determine whether this feature is available.
  */

 bool
   PLIB_SPI_ReceiverHasOverflowed (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_ReceiverOverflowClear(SPI_MODULE_ID index)
   Summary:
     Clears the SPI receive overflow flag.
   Description:
     This function clears the SPI receive overflow flag.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
    None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_ReceiverOverflowClear(MY_SPI_INSTANCE);
     </code>
   Remarks:
     This function implements an operation of the receiver overflow status feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsReceiverOverflow"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_ReceiverOverflowClear (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_SPI_TransmitBufferIsFull (SPI_MODULE_ID index)
   Summary:
     Returns the current transmit buffer status of the SPI module.
   Description:
     This function returns the current transmit buffer status of the SPI module.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     - true - Transmit not yet started, transmit buffer is full
     - false - Transmit started, transmit buffer is empty/not full
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     bool buffullstate = PLIB_SPI_TransmitBufferIsFull (MY_SPI_INSTANCE);
     </code>
   Remarks:
     In Standard Buffer mode - automatically set in hardware when SPI buffer writes
     occur, loading the transmit buffer. Automatically cleared in hardware when
      the SPI module transfers data from the transmit buffer to the shift register.
     In Enhanced Buffer mode - automatically set in hardware when SPI buffer writes
     occur, loading the last available buffer. Automatically cleared in hardware
     when the buffer is available for writing.
     This function implements an operation of the transmit buffer status feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsTransmitBufferFullStatus"
     in your application to automatically determine whether this feature is available.
  */

 bool
   PLIB_SPI_TransmitBufferIsFull (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_SPI_ReceiverBufferIsFull (SPI_MODULE_ID index)
   Summary:
     Returns the current status of the SPI receive buffer.
   Description:
     This function returns the current status of the SPI receive buffer.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     Receiver Buffer Full Status:
     - true - Receive complete, receive buffer is full
     - false - Receive is not complete, receive buffer is empty
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     bool receivefullstate = PLIB_SPI_ReceiverBufferIsFull (MY_SPI_INSTANCE);
     </code>
   Remarks:
     In Standard Buffer mode - automatically set in hardware when the SPI module
     transfers data from the shift register to the receive buffer. Automatically
     cleared in hardware when the core reads the SPI buffer, read in the receive buffer.
     In Enhanced Buffer mode - automatically set in hardware when the SPI module
     transfers data from the shift register to the receive buffer, filling the
     last unread buffer. Automatically cleared in hardware when a buffer is available
     for a transfer from the shift register.
     This function implements an operation of the receiver buffer status feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsReceiveBufferStatus"
     in your application to automatically determine whether this feature is available.
  */

 bool
   PLIB_SPI_ReceiverBufferIsFull (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_PinEnable (SPI_MODULE_ID index,SPI_PIN pin)
   Summary:
     Enables the selected SPI pins.
   Description:
     This function enables the selected SPI pins.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     pin - One of the SPI_PIN enumeration values as the SPI pin
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_PinEnable(MY_SPI_INSTANCE, SPI_PIN_SLAVE_SELECT);
     </code>
   Remarks:
     This function implements an operation of the pin control feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsPinControl"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_PinEnable (
   SPI_MODULE_ID index ,
   SPI_PIN pin ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_PinDisable (SPI_MODULE_ID index, SPI_PIN pin)
   Summary:
     Enables the selected SPI pins.
   Description:
     This function enables the selected SPI pins.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     pin - One of the SPI_PIN enumeration values as the SPI pin
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_PinDisable(MY_SPI_INSTANCE, SPI_PIN_SLAVE_SELECT);
     </code>
   Remarks:
     This function implements an operation of the pin control feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsPinControl"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_PinDisable (
   SPI_MODULE_ID index ,
   SPI_PIN pin ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_CommunicationWidthSelect (SPI_MODULE_ID index,
                                             SPI_COMMUNICATION_WIDTH width )
   Summary:
     Selects the data width for the SPI communication.
   Description:
     This function selects the data width for the SPI communication.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     width - One of the SPI_COMMUNICATION_WIDTH enumeration values as the
                       SPI buffer width
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_CommunicationWidthSelect(MY_SPI_INSTANCE, SPI_COMMUNICATION_WIDTH_8BITS);
     </code>
   Remarks:
     This function implements an operation of the communication width feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsCommunicationWidth"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_CommunicationWidthSelect (
   SPI_MODULE_ID index ,
   SPI_COMMUNICATION_WIDTH width ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_AudioCommunicationWidthSelect (SPI_MODULE_ID index,
                                                  SPI_AUDIO_COMMUNICATION_WIDTH width )
   Summary:
     Selects the data width for the SPI audio communication.
   Description:
     This function selects the data width for the SPI audio communication.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     width - One of the SPI_AUDIO_COMMUNICATION_WIDTH enumeration values as the
                       SPI buffer width
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_AudioCommunicationWidthSelect(MY_SPI_INSTANCE,
                                SPI_AUDIO_COMMUNICATION_32DATA_32FIFO_32CHANNEL);
     </code>
   Remarks:
    This mode is available only when PLIB_SPI_AudioProtocolEnable is enabled.
     This function implements an operation of the audio communication width feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsAudioCommunicationWidth"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_AudioCommunicationWidthSelect (
   SPI_MODULE_ID index ,
   SPI_AUDIO_COMMUNICATION_WIDTH mode ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_InputSamplePhaseSelect(SPI_MODULE_ID index,
                                          SPI_INPUT_SAMPLING_PHASE phase)
   Summary:
     Selects the SPI data input sample phase.
   Description:
     This function selects the input sampling phase in Master mode.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     phase - One of the SPI_INPUT_SAMPLING_PHASE as the SPI input
                       sampling phase
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_InputSamplePhaseSelect(MY_SPI_INSTANCE, SPI_INPUT_SAMPLING_PHASE_IN_MIDDLE);
     </code>
   Remarks:
     This function implements an operation of the input sample phase feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsInputSamplePhase"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_InputSamplePhaseSelect (
   SPI_MODULE_ID index ,
   SPI_INPUT_SAMPLING_PHASE phase ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_OutputDataPhaseSelect (SPI_MODULE_ID index,
                                          SPI_OUTPUT_DATA_PHASE data)
   Summary:
     Selects serial output data change.
   Description:
     This function selects serial output data change.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     data - One of the SPI_OUTPUT_DATA_PHASE enumeration values as the
                       SPI serial output data change
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_OutputDataPhaseSelect(MY_SPI_INSTANCE, SPI_OUTPUT_DATA_PHASE_ON_ACTIVE_TO_IDLE_CLOCK);
     </code>
   Remarks:
     This function implements an operation of the output data phase feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsOutputDataPhase"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_OutputDataPhaseSelect (
   SPI_MODULE_ID index ,
   SPI_OUTPUT_DATA_PHASE phase ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_ClockPolaritySelect(SPI_MODULE_ID index,
                                       SPI_CLOCK_POLARITY polarity)
   Summary:
     Enables clock polarity.
   Description:
     This function enables clock polarity.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     polarity - One of the SPI_CLOCK_POLARITY enumeration values as the SPI clock polarity
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_ClockPolaritySelect(MY_SPI_INSTANCE, SPI_CLOCK_POLARITY_IDLE_HIGH );
     </code>
   Remarks:
     This function implements an operation of the clock polarity feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsClockPolarity"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_ClockPolaritySelect (
   SPI_MODULE_ID index ,
   SPI_CLOCK_POLARITY polarity ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_MasterEnable(SPI_MODULE_ID index)
   Summary:
     Enables the SPI in Master mode.
   Description:
     This function enables the SPI in Master mode.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_MasterEnable(MY_SPI_INSTANCE);
     </code>
   Remarks:
     This function implements an operation of the master enable control feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsMasterControl"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_MasterEnable (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_SlaveEnable(SPI_MODULE_ID index)
   Summary:
     Enables the SPI in Slave mode.
   Description:
     This function enables the SPI in Slave mode.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_SlaveEnable(MY_SPI_INSTANCE);
     </code>
   Remarks:
     This function implements an operation of the master enable control feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsMasterControl"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_SlaveEnable (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
    void PLIB_SPI_BaudRateSet(SPI_MODULE_ID index, uint32_t clockFrequency,
                              uint32_t baudRate )
   Summary:
     Sets the baud rate to the desired value.
   Description:
     This function sets the baud rate to the desired value.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     clockFrequency - Clock frequency
     baudrate - Baud rate value
   Returns:
     None.
   Example:
     <code>
      // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_BaudRateSet(MY_SPI_INSTANCE, MY_CLOCK_FREQUENCY, 9600);
     </code>
   Remarks:
     Setting a new baud rate value causes the baud rate timer to reset.
     This ensures that the baud rate timer does not have to overflow before
     outputting the new baud rate.
     If the system clock is changed during an active receive operation, a
     receive error or data loss may result. To avoid this issue, verify that
     no receptions are in progress before changing the system clock.
     This function implements an operation of the baud rate set feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsBaudRate"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_BaudRateSet (
   SPI_MODULE_ID index ,
   uint32_t clockFrequency ,
   uint32_t baudRate ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_SPI_IsBusy (SPI_MODULE_ID index)
   Summary:
     Returns the current SPI module activity status.
   Description:
     This function returns the current SPI module activity status.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     - true - SPI module is currently busy with some transactions
     - false - SPI module is currently idle
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     bool status = PLIB_SPI_IsBusy(MY_SPI_INSTANCE);
     </code>
   Remarks:
     This function implements an operation of the bus status feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsBusStatus"
     in your application to automatically determine whether this feature is available.
  */

 bool
   PLIB_SPI_IsBusy (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_SPI_ReadDataIsSignExtended(SPI_MODULE_ID index)
   Summary:
     Returns the current status of the receive (RX) FIFO sign-extended data.
   Description:
     This function returns the current status of the receive (RX) FIFO
     sign-extended data.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     - true - Data from RX FIFO is sign-extended
     - false - Data from RX FIFO is not sign-extended
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     bool Status = PLIB_SPI_ReadDataIsSignExtended(MY_SPI_INSTANCE);
     </code>
   Remarks:
     This function implements an operation of the data sign feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsReadDataSignStatus"
     in your application to automatically determine whether this feature is available.
  */

 bool
   PLIB_SPI_ReadDataIsSignExtended (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_SlaveSelectEnable(SPI_MODULE_ID index)
   Summary:
     Enables Master mode slave select.
   Description:
     This function enables Master mode slave select.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_SlaveSelectEnable(MY_SPI_INSTANCE);
     </code>
   Remarks:
     This feature does not support Framed SPI mode.
     This function implements an operation of the Master mode slave select feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsSlaveSelectControl"
     in your application to automatically determine whether this feature is available.

     To enable Slave mode slave select pin (SSEN), PLIB_SPI_PinEnable API can be used.
  */

 void
   PLIB_SPI_SlaveSelectEnable (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_SlaveSelectDisable(SPI_MODULE_ID index)
   Summary:
     Disables Master mode slave select.
   Description:
     This function disables Master mode slave select.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_SlaveSelectDisable(MY_SPI_INSTANCE);
     </code>
   Remarks:
     This feature does not support Framed SPI mode.
     This function implements an operation of the slave select feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsSlaveSelectControl"
     in your application to automatically determine whether this feature is available.

     To disable Slave mode slave select pin (SSEN), PLIB_SPI_PinDisable API can be used.
  */

 void
   PLIB_SPI_SlaveSelectDisable (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_SPI_TransmitUnderRunStatusGet(SPI_MODULE_ID index)
   Summary:
     Returns the current status of the transmit underrun.
   Description:
     This function returns the current status of the transmit underrun.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     - true - Transmit buffer has encountered an underrun condition
     - false - Transmit buffer run has not encountered an underrun condition
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     bool Status = PLIB_SPI_TransmitUnderRunStatusGet(MY_SPI_INSTANCE);
     </code>
   Remarks:
     Valid in Framed Sync mode.
     This function implements an operation of the transmit underrun status feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsTransmitUnderRunStatus"
     in your application to automatically determine whether this feature is available.
  */

 bool
   PLIB_SPI_TransmitUnderRunStatusGet (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_TransmitUnderRunStatusClear(SPI_MODULE_ID index)
   Summary:
     Clears the SPI transmit underrun flag.
   Description:
     This function clears the SPI transmit underrun flag.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
    None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_TransmitUnderRunStatusClear(MY_SPI_INSTANCE);
     </code>
   Remarks:
     This function implements an operation of the transmit underrun status feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "ExistsTransmitUnderRunStatus"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_TransmitUnderRunStatusClear (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_SPI_TransmitBufferIsEmpty (SPI_MODULE_ID index)
   Summary:
     Returns the current status of the transmit buffer.
   Description:
     This function returns the current status of the transmit buffer.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     - true - Transmit buffer is empty
     - false - Transmit buffer is not empty
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     bool Status = PLIB_SPI_TransmitBufferIsEmpty(MY_SPI_INSTANCE);
     </code>
   Remarks:
     This function implements an operation of the transmit buffer empty status feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsTransmitBufferEmptyStatus"
     in your application to automatically determine whether this feature is available.
  */

 bool
   PLIB_SPI_TransmitBufferIsEmpty (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_FIFOEnable (SPI_MODULE_ID index)
   Summary:
     Enables the SPI enhanced buffer.
   Description:
     This function enables the SPI enhanced buffer.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_FIFOEnable(MY_SPI_INSTANCE);
     </code>
   Remarks:
     This enables the enhanced buffer mode.
     This function implements an operation of the FIFO control feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsFIFOControl"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_FIFOEnable (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_FIFODisable (SPI_MODULE_ID index)
   Summary:
     Disables the SPI enhanced buffer.
   Description:
     This function disables the SPI enhanced buffer.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_FIFODisable(MY_SPI_INSTANCE);
     </code>
   Remarks:
     Enables the legacy standard single buffer mode.
     This function implements an operation of the FIFO control feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsFIFOControl"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_FIFODisable (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     uint8_t PLIB_SPI_FIFOCountGet (SPI_MODULE_ID index, SPI_FIFO_TYPE type)
   Summary:
     Reads the SPI Buffer Element Count bits for either receive or transmit.
   Description:
     This function reads the number of SPI transfers pending for Master mode
     and the number of unread SPI transfers for Slave mode.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     type - One of the SPI_FIFO_TYPE enumeration values
   Returns:
     CountValue - Buffer element count bits
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     uint8_t count = PLIB_SPI_FIFOCountGet(MY_SPI_INSTANCE,SPI_FIFO_TYPE_TRANSMIT);
     </code>
   Remarks:
     Valid in Enhanced Buffer mode.
     This function implements an operation of the FIFO control feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsFIFOCount"
     in your application to automatically determine whether this feature is available.
  */

 uint8_t
   PLIB_SPI_FIFOCountGet (
   SPI_MODULE_ID index ,
   SPI_FIFO_TYPE type ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_SPI_FIFOShiftRegisterIsEmpty (SPI_MODULE_ID index)
   Summary:
     Returns the current status of the SPI shift register.
   Description:
     This function returns the current status of the SPI shift register.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     - true - SPI shift register is empty and ready to send or receive
     - false - SPI shift register is not empty
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     bool Status = PLIB_SPI_FIFOShiftRegisterIsEmpty(MY_SPI_INSTANCE);
     </code>
   Remarks:
     Valid in Enhanced Buffer mode.
     This function implements an operation of the FIFO status feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsFIFOShiftRegisterEmptyStatus"
     in your application to automatically determine whether this feature is available.
  */

 bool
   PLIB_SPI_FIFOShiftRegisterIsEmpty (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_SPI_ReceiverFIFOIsEmpty (SPI_MODULE_ID index)
   Summary:
     Returns the current status of the SPI receive FIFO.
   Description:
     This function returns the current status of the SPI receive FIFO.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     - true - Receive FIFO is empty
     - false - Receive FIFO is not empty
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     bool fifostate = PLIB_SPI_ReceiverFIFOIsEmpty (MY_SPI_INSTANCE);
     </code>
   Remarks:
     Valid in Enhanced Buffer mode.
     This function implements an operation of the FIFO status feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsReceiveFIFOStatus"
     in your application to automatically determine whether this feature is available.
  */

 bool
   PLIB_SPI_ReceiverFIFOIsEmpty (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_FIFOInterruptModeSelect (SPI_MODULE_ID index,
                                            SPI_FIFO_INTERRUPT mode)
   Summary:
     Selects the SPI buffer interrupt mode.
   Description:
     This function selects the SPI buffer interrupt mode from SPI_FIFO_INTERRUPT.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     mode - One of the SPI_FIFO_INTERRUPT enumeration values as the SPI buffer
                       interrupt mode
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_FIFOInterruptModeSelect(MY_SPI_INSTANCE,
                     SPI_FIFO_INTERRUPT_WHEN_TRANSMIT_BUFFER_IS_NOT_FULL);
     </code>
   Remarks:
     Valid in Enhanced Buffer mode.
     This function implements an operation of the FIFO interrupt feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsFIFOInterruptMode"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_FIFOInterruptModeSelect (
   SPI_MODULE_ID index ,
   SPI_FIFO_INTERRUPT mode ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_FramedCommunicationEnable (SPI_MODULE_ID index)
   Summary:
     Enables framed SPI support.
   Description:
     This function enables framed SPI support.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_FramedCommunicationEnable(MY_SPI_INSTANCE);
     </code>
   Remarks:
     This function implements an operation of the framed communication feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsFramedCommunication"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_FramedCommunicationEnable (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_FramedCommunicationDisable (SPI_MODULE_ID index)
   Summary:
     Disables framed SPI support.
   Description:
     This function disables framed SPI support.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_FramedCommunicationDisable(MY_SPI_INSTANCE);
     </code>
   Remarks:
     This function implements an operation of the framed communication feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsFramedCommunication"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_FramedCommunicationDisable (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_FrameSyncPulseDirectionSelect (SPI_MODULE_ID index,
                                                  SPI_FRAME_PULSE_DIRECTION direction)
   Summary:
     Selects the frame sync pulse direction.
   Description:
     This function selects the frame sync pulse direction.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     direction - One of the SPI_FRAME_PULSE_DIRECTION enumeration values
                       as the SPI frame sync pulse polarity
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_FrameSyncPulseDirectionSelect(MY_SPI_INSTANCE, SPI_FRAME_PULSE_DIRECTION_INPUT );
     </code>
   Remarks:
     This function implements an operation of the framed communication feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsFrameSyncPulseDirection"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_FrameSyncPulseDirectionSelect (
   SPI_MODULE_ID index ,
   SPI_FRAME_PULSE_DIRECTION direction ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_FrameSyncPulsePolaritySelect (SPI_MODULE_ID index,
                                                 SPI_FRAME_PULSE_POLARITY polarity)
   Summary:
     Selects the frame sync pulse polarity.
   Description:
     This function selects the frame sync pulse polarity.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     polarity - One of the SPI_FRAME_PULSE_POLARITY enumeration values as the SPI frame
                       sync pulse polarity
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_FrameSyncPulsePolaritySelect(MY_SPI_INSTANCE, SPI_FRAME_PULSE_POLARITY_ACTIVE_HIGH );
     </code>
   Remarks:
     Available only for Frame mode.
     This function implements an operation of the framed communication feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsFrameSyncPulsePolarity"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_FrameSyncPulsePolaritySelect (
   SPI_MODULE_ID index ,
   SPI_FRAME_PULSE_POLARITY polarity ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_FrameSyncPulseEdgeSelect (SPI_MODULE_ID index,
                                             SPI_FRAME_PULSE_EDGE edge)
   Summary:
     Selects the frame sync pulse edge.
   Description:
     This function selects the frame sync pulse edge.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     edge - One of the SPI_FRAME_PULSE_EDGE enumeration values as the
                       SPI frame sync pulse edge
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_FrameSyncPulseEdgeSelect(MY_SPI_INSTANCE,
                        SPI_FRAME_PULSE_EDGE_COINCIDES_FIRST_BIT_CLOCK);
     </code>
   Remarks:
     This function implements an operation of the framed communication feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsFrameSyncPulseEdge"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_FrameSyncPulseEdgeSelect (
   SPI_MODULE_ID index ,
   SPI_FRAME_PULSE_EDGE edge ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_FrameSyncPulseWidthSelect (SPI_MODULE_ID index,
                                              SPI_FRAME_PULSE_WIDTH width)
   Summary:
     Sets the frame sync pulse width.
   Description:
     This function sets the frame sync pulse width.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     edge - One of the SPI_FRAME_PULSE_WIDTH enumeration values as the SPI
                       frame sync pulse width.
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_FrameSyncPulseWidthSelect (MY_SPI_INSTANCE,SPI_FRAME_PULSE_WIDTH_ONE_WORD_LENGTH);
     </code>
   Remarks:
     Length of the word is dependent on the communication mode.
     This function implements an operation of the framed communication feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsFrameSyncPulseWidth"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_FrameSyncPulseWidthSelect (
   SPI_MODULE_ID index ,
   SPI_FRAME_PULSE_WIDTH width ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_FrameSyncPulseCounterSelect (SPI_MODULE_ID index,
                                                SPI_FRAME_SYNC_PULSE pulse)
   Summary:
     Selects at which character the SPI frame sync pulse is generated.
   Description:
     This function selects at which character the SPI frame sync pulse is generated.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     pulse - One of the SPI_FRAME_SYNC_PULSE enumeration values as the SPI
                       frame sync pulse count
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_FrameSyncPulseCounterSelect(MY_SPI_INSTANCE,
                                             SPI_FRAME_SYNC_PULSE_ON_EVERY_32_DATA_CHARACTER );
     </code>
   Remarks:
     This is valid only when PLIB_SPI_FramedCommunicationEnable is enabled.
     This function implements an operation of the framed communication feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsFrameSyncPulseCounter"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_FrameSyncPulseCounterSelect (
   SPI_MODULE_ID index ,
   SPI_FRAME_SYNC_PULSE pulse ) ;
 //******************************************************************************
 /* Function:
     bool PLIB_SPI_FrameErrorStatusGet (SPI_MODULE_ID index)
   Summary:
     Returns the current status of the SPI frame error.
   Description:
     This function returns the current status of the SPI frame error.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     - true - Frame error detected
     - false - No frame error detected
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     bool status = PLIB_SPI_FrameErrorStatusGet(MY_SPI_INSTANCE);
     </code>
   Remarks:
         Valid only if Frame mode is enabled.
     This function implements an operation of the framed communication feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsFrameErrorStatus"
     in your application to automatically determine whether this feature is available.
  */

 bool
   PLIB_SPI_FrameErrorStatusGet (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_FrameErrorStatusClear(SPI_MODULE_ID index)
   Summary:
     Clears the SPI frame error flag.
   Description:
     This function clears the SPI frame error flag.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
    None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_FrameErrorStatusClear(MY_SPI_INSTANCE);
     </code>
   Remarks:
     This function implements an operation of the frame error status feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "ExistsFrameErrorStatus"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_FrameErrorStatusClear (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_BufferClear (SPI_MODULE_ID index)
   Summary:
     Clears the SPI receive buffer.
   Description:
     This function clears the SPI receive buffer.
     In Enhanced Buffer mode, this functions clears the full RX FIFO.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
      // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     //This call will flush the receive buffer.
     PLIB_SPI_BufferClear(MY_SPI_INSTANCE);
     </code>
   Remarks:
     This function implements an operation of the buffer control feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsBuffer"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_BufferClear (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     uint8_t PLIB_SPI_BufferRead (SPI_MODULE_ID index)
   Summary:
     Returns the SPI buffer value.
   Description:
     This function returns the SPI buffer value.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
      Reads the SPI buffer.
   Example:
     <code>
      // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     uint8_t bufferValue = PLIB_SPI_BufferRead(MY_SPI_INSTANCE);
     </code>
   Remarks:
     This function implements an operation of the buffer control feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsBuffer"
     in your application to automatically determine whether this feature is available.
  */

 uint8_t
   PLIB_SPI_BufferRead (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     uint16_t PLIB_SPI_BufferRead16bit ( SPI_MODULE_ID index )
   Summary:
     Returns 16-bit SPI buffer value.
   Description:
     This function returns 16-bit SPI buffer value.
     This operation is atomic.
   Precondition:
     SPI 16-bit wide communication must be selected using PLIB_SPI_CommunicationWidthSelect.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     Returns the SPI 16-bit buffer value.
   Example:
     <code>
 #define MY_SPI_INSTANCE SPI_ID_1

     uint16_t bufferValue = PLIB_SPI_BufferRead16bit( MY_SPI_INSTANCE );
     </code>
   Remarks:
     This function implements an operation of the buffer control feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_Exists16bitBuffer"
     in your application to automatically determine whether this feature is available.
  */

 uint16_t
   PLIB_SPI_BufferRead16bit (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     uint32_t PLIB_SPI_BufferRead32bit ( SPI_MODULE_ID index )
   Summary:
     Returns 32-bit SPI buffer value.
   Description:
     This function returns 32-bit SPI buffer value.
     This operation is atomic.
   Precondition:
     SPI 32-bit wide communication must be selected using PLIB_SPI_CommunicationWidthSelect.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     Returns the SPI 32-bit buffer value.
   Example:
     <code>
 #define MY_SPI_INSTANCE SPI_ID_1

     uint32_t bufferValue = PLIB_SPI_BufferRead32bit( MY_SPI_INSTANCE );
     </code>
   Remarks:
     This function implements an operation of the buffer control feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_Exists32bitBuffer"
     in your application to automatically determine whether this feature is available.
  */

 uint32_t
   PLIB_SPI_BufferRead32bit (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_BufferWrite ( SPI_MODULE_ID index , uint8_t data )
   Summary:
     Write the data to the SPI buffer.
   Description:
     This function writes data to the SPI buffer.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     data - Data to written to the SPI buffer
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_BufferWrite ( MY_SPI_INSTANCE, 0xFF );
     </code>
   Remarks:
     This function implements an operation of the buffer control feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsBuffer"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_BufferWrite (
   SPI_MODULE_ID index ,
   uint8_t data ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_BufferWrite16bit ( SPI_MODULE_ID index , uint16_t data )
   Summary:
     Writes 16-bit data to the SPI buffer.
   Description:
     This function writes 16-bit data to the SPI buffer.
     This operation is atomic.
   Precondition:
     SPI 16-bit wide communication must be selected using PLIB_SPI_CommunicationWidthSelect.
   Parameters:
     index - Identifier for the device instance to be configured
     data - 16-bit data to be written to the SPI buffer
   Returns:
     None.
   Example:
     <code>
 #define MY_SPI_INSTANCE SPI_ID_1

     PLIB_SPI_BufferWrite16bit ( MY_SPI_INSTANCE, 0x55AA );
     </code>
   Remarks:
     This function implements an operation of the buffer control feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_Exists16bitBuffer"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_BufferWrite16bit (
   SPI_MODULE_ID index ,
   uint16_t data ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_BufferWrite32bit ( SPI_MODULE_ID index , uint32_t data )
   Summary:
     Write 32-bit data to the SPI buffer.
   Description:
     This function writes 32-bit data to the SPI buffer.
     This operation is atomic.
   Precondition:
     SPI 32-bit wide communication must be selected using PLIB_SPI_CommunicationWidthSelect.
   Parameters:
     index - Identifier for the device instance to be configured
     data - 32-bit data to be written to the SPI buffer
   Returns:
     None.
   Example:
     <code>
 #define MY_SPI_INSTANCE SPI_ID_1

     PLIB_SPI_BufferWrite ( MY_SPI_INSTANCE, 0x55AA55AA );
     </code>
   Remarks:
     This function implements an operation of the buffer control feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_Exists32bitBuffer"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_BufferWrite32bit (
   SPI_MODULE_ID index ,
   uint32_t data ) ;
 //******************************************************************************
 /* Function : PLIB_SPI_BufferAddressGet( SPI_MODULE_ID index )
   Summary:
     Returns the address of the SPIxBUF (Transmit(SPIxTXB) and Receive (SPIxRXB))
         register.
   Description:
     This function returns the address of the SPIxBUF (Transmit(SPIxTXB) and Receive
     (SPIxRXB)) register.
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     The address of the SPIxBUF register
   Remarks:
     None.
 */

 void *
   PLIB_SPI_BufferAddressGet (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_BaudRateClockSelect (SPI_MODULE_ID index,
                                        SPI_BAUD_RATE_CLOCK type)
   Summary:
     Selects the type of clock is used by the Baud Rate Generator.
   Description:
     This function selects the type of clock is used by the Baud Rate Generator.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     type - One of the SPI_BAUD_RATE_CLOCK enumeration values as the SPI baud clock
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_BaudRateClockSelect (MY_SPI_INSTANCE, SPI_BAUD_RATE_MCLK_CLOCK);
     </code>
  Remarks:
     This function implements an operation of the baud rate clock control feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsBaudRateClock"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_BaudRateClockSelect (
   SPI_MODULE_ID index ,
   SPI_BAUD_RATE_CLOCK type ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_ErrorInterruptEnable (SPI_MODULE_ID index,
                                         SPI_ERROR_INTERRUPT error)
   Summary:
     Enables SPI error interrupts
   Description:
     This function enables SPI error interrupts.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     type - One of the SPI_ERROR_INTERRUPT enumeration values as the
                       SPI interrupt error
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_ErrorInterruptEnable (MY_SPI_INSTANCE, SPI_ERROR_INTERRUPT_FRAME_ERROR_OVERFLOW);
     </code>
   Remarks:
     This function implements an operation of the error interrupt control feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsErrorInterruptControl"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_ErrorInterruptEnable (
   SPI_MODULE_ID index ,
   SPI_ERROR_INTERRUPT error ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_ErrorInterruptDisable (SPI_MODULE_ID index,
                                          SPI_ERROR_INTERRUPT error)
   Summary:
     Enables SPI error interrupts.
   Description:
     This function enables SPI error interrupts.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     error - One of the SPI_ERROR_INTERRUPT enumeration values as the
                       SPI interrupt error
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_ErrorInterruptDisable (MY_SPI_INSTANCE, SPI_ERROR_INTERRUPT_FRAME_ERROR_OVERFLOW);
     </code>
   Remarks:
     This function implements an operation of the error interrupt control feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsErrorInterruptControl"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_ErrorInterruptDisable (
   SPI_MODULE_ID index ,
   SPI_ERROR_INTERRUPT error ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_AudioErrorEnable (SPI_MODULE_ID index, SPI_Audio_ERROR error)
   Summary:
     Enables the SPI error.
   Description:
     This function enables the SPI error.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     error - One of the SPI_AUDIO_ERROR enumeration values as the SPI error
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_AudioErrorEnable (MY_SPI_INSTANCE, SPI_AUDIO_ERROR_RECEIVE_OVERFLOW);
     </code>
   Remarks:
     This function implements an operation of the audio error control feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsAudioErrorControl"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_AudioErrorEnable (
   SPI_MODULE_ID index ,
   SPI_AUDIO_ERROR error ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_AudioErrorDisable (SPI_MODULE_ID index, SPI_AUDIO_ERROR error)
   Summary:
     Disables the SPI error.
   Description:
     This function disables the SPI error.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     error - One of the SPI_AUDIO_ERROR enumeration values as the SPI error
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_AudioErrorDisable (MY_SPI_INSTANCE, SPI_AUDIO_ERROR_RECEIVE_OVERFLOW);
     </code>
   Remarks:
     This function implements an operation of the audio error control feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsAudioErrorControl"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_AudioErrorDisable (
   SPI_MODULE_ID index ,
   SPI_AUDIO_ERROR error ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_AudioProtocolEnable (SPI_MODULE_ID index)
   Summary:
     Audio protocol is enabled.
   Description:
     This function enables the audio protocol.
     This operation is atomic.
   Precondition:
     Disable the SPI module by calling PLIB_SPI_Disable.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_AudioProtocolEnable(MY_SPI_INSTANCE);
     </code>
   Remarks:
     This function implements an operation of the audio protocol control feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsAudioProtocolControl"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_AudioProtocolEnable (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_AudioProtocolDisable (SPI_MODULE_ID index)
   Summary:
     Audio protocol is disabled.
   Description:
     This function disables the audio protocol.
     This operation is atomic.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_AudioProtocolDisable(MY_SPI_INSTANCE);
     </code>
   Remarks:
     This function implements an operation of the audio protocol control feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsAudioProtocolControl"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_AudioProtocolDisable (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_AudioTransmitModeSelect (SPI_MODULE_ID index,
                                            SPI_AUDIO_TRANSMIT_MODE mode)
  Summary:
     Selects the transmit audio data format.
   Description:
     This function selects the transmit audio data format.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     mode - One of the SPI_TRANSMIT_AUDIO_MODE enumeration values as the
                       transmit audio format
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_AudioTransmitModeSelect (MY_SPI_INSTANCE, SPI_AUDIO_TRANSMIT_MONO);
     </code>
   Remarks:
     This function implements an operation of the audio transmit mode feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsAudioTransmitMode"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_AudioTransmitModeSelect (
   SPI_MODULE_ID index ,
   SPI_AUDIO_TRANSMIT_MODE mode ) ;
 //******************************************************************************
 /* Function:
     void PLIB_SPI_AudioProtocolModeSelect(SPI_MODULE_ID index,
                                           SPI_AUDIO_PROTOCOL mode )
   Summary:
     Selects the Audio Protocol mode.
   Description:
     This function selects the Audio Protocol mode.
   Precondition:
     None.
   Parameters:
     index - Identifier for the device instance to be configured
     mode - One of the SPI_AUDIO_PROTOCOL enumeration values as the
                       audio protocol
   Returns:
     None.
   Example:
     <code>
     // Where MY_SPI_INSTANCE, is the SPI instance selected for use by the
     // application developer.
     PLIB_SPI_AudioProtocolModeSelect(MY_SPI_INSTANCE,SPI_AUDIO_PROTOCOL_RIGHT_JUSTIFIED );
     </code>
   Remarks:
     This function implements an operation of the audio protocol mode feature.
     This feature may not be available on all devices. Please refer to the
     specific device data sheet to determine availability or use "PLIB_SPI_ExistsAudioProtocolMode"
     in your application to automatically determine whether this feature is available.
  */

 void
   PLIB_SPI_AudioProtocolModeSelect (
   SPI_MODULE_ID index ,
   SPI_AUDIO_PROTOCOL mode ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: SPI Peripheral Library Exists Functions
 // *****************************************************************************
 // *****************************************************************************
 /* The following functions indicate the existence of the features on the device.
 */
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsEnableControl( SPI_MODULE_ID index )
   Summary:
     Identifies whether the EnableControl feature exists on the SPI module.
   Description:
     This function identifies whether the EnableControl feature is available on
         the SPI module.
     When this function returns true, these functions are supported on the device:
     - PLIB_SPI_Enable
     - PLIB_SPI_Disable
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The EnableControl feature is supported on the device
     - false - The EnableControl feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsEnableControl (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsStopInIdleControl( SPI_MODULE_ID index )
   Summary:
     Identifies whether the StopInIdle feature exists on the SPI module.
   Description:
     This function identifies whether the StopInIdle feature is available on the
         SPI module.
     When this function returns true, these functions are supported on the device:
     - PLIB_SPI_StopInIdleEnable
     - PLIB_SPI_StopInIdleDisable
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The StopInIdle feature is supported on the device
     - false - The StopInIdle feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsStopInIdleControl (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsReceiverOverflow( SPI_MODULE_ID index )
   Summary:
     Identifies whether the ReceiverOverflow feature exists on the SPI module.
   Description:
     This function identifies whether the ReceiverOverflow feature is available
         on the SPI module.
     When this function returns true, these functions are supported on the device:
     - PLIB_SPI_ReceiverHasOverflowed
     - PLIB_SPI_ReceiverOverflowClear
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ReceiverOverflow feature is supported on the device
     - false - The ReceiverOverflow feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsReceiverOverflow (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsTransmitBufferFullStatus( SPI_MODULE_ID index )
   Summary:
     Identifies whether the TransmitBufferFullStatus feature exists on the SPI module.
   Description:
     This function identifies whether the TransmitBufferFullStatus feature is available
         on the SPI module.
     When this function returns true, this function is supported on the device:
     - PLIB_SPI_TransmitBufferIsFull
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The TransmitBufferFullStatus feature is supported on the device
     - false - The TransmitBufferFullStatus feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsTransmitBufferFullStatus (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsTransmitBufferEmptyStatus( SPI_MODULE_ID index )
   Summary:
     Identifies whether the TransmitBufferEmptyStatus feature exists on the SPI module.
   Description:
     This function identifies whether the TransmitBufferEmptyStatus feature is available
         on the SPI module.
     When this function returns true, this function is supported on the device:
     - PLIB_SPI_TransmitBufferIsEmpty
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The TransmitBufferEmptyStatus feature is supported on the device
     - false - The TransmitBufferEmptyStatus feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsTransmitBufferEmptyStatus (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsReceiveBufferStatus( SPI_MODULE_ID index )
   Summary:
     Identifies whether the ReceiveBufferStatus feature exists on the SPI module.
   Description:
     This function identifies whether the ReceiveBufferStatus feature is available
         on the SPI module.
     When this function returns true, this function is supported on the device:
     - PLIB_SPI_ReceiverBufferIsFull
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ReceiveBufferStatus feature is supported on the device
     - false - The ReceiveBufferStatus feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsReceiveBufferStatus (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsPinControl( SPI_MODULE_ID index )
   Summary:
     Identifies whether the PinControl feature exists on the SPI module.
   Description:
     This function identifies whether the PinControl feature is available on the
         SPI module.
     When this function returns true, these functions are supported on the device:
     - PLIB_SPI_PinEnable
     - PLIB_SPI_PinDisable
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The PinControl feature is supported on the device
     - false - The PinControl feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsPinControl (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsCommunicationWidth( SPI_MODULE_ID index )
   Summary:
     Identifies whether the CommunicationWidth feature exists on the SPI module.
   Description:
     This function identifies whether the CommunicationWidth feature is available
         on the SPI module.
     When this function returns true, this function is supported on the device:
     - PLIB_SPI_CommunicationWidthSelect
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The CommunicationWidth feature is supported on the device
     - false - The CommunicationWidth feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsCommunicationWidth (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsAudioCommunicationWidth( SPI_MODULE_ID index )
   Summary:
     Identifies whether the AudioCommunicationWidth feature exists on the SPI module.
   Description:
     This function identifies whether the AudioCommunicationWidth feature is available
         on the SPI module.
     When this function returns true, this function is supported on the device:
     - PLIB_SPI_AudioCommunicationWidthSelect
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The AudioCommunicationWidth feature is supported on the device
     - false - The AudioCommunicationWidth feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsAudioCommunicationWidth (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsInputSamplePhase( SPI_MODULE_ID index )
   Summary:
     Identifies whether the InputSamplePhase feature exists on the SPI module.
   Description:
     This function identifies whether the InputSamplePhase feature is available
         on the SPI module.
     When this function returns true, this function is supported on the device:
     - PLIB_SPI_InputSamplePhaseSelect
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The InputSamplePhase feature is supported on the device
     - false - The InputSamplePhase feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsInputSamplePhase (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsOutputDataPhase( SPI_MODULE_ID index )
   Summary:
     Identifies whether the OutputDataPhase feature exists on the SPI module.
   Description:
     This function identifies whether the OutputDataPhase feature is available on
         the SPI module.
     When this function returns true, this function is supported on the device:
     - PLIB_SPI_OutputDataPhaseSelect
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The OutputDataPhase feature is supported on the device
     - false - The OutputDataPhase feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsOutputDataPhase (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsClockPolarity( SPI_MODULE_ID index )
   Summary:
     Identifies whether the ClockPolarity feature exists on the SPI module.
   Description:
     This function identifies whether the ClockPolarity feature is available on
         the SPI module.
     When this function returns true, this function is supported on the device:
     - PLIB_SPI_ClockPolaritySelect
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ClockPolarity feature is supported on the device
     - false - The ClockPolarity feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsClockPolarity (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsMasterControl( SPI_MODULE_ID index )
   Summary:
     Identifies whether the MasterControl feature exists on the SPI module.
   Description:
     This function identifies whether the MasterControl feature is available on
         the SPI module.
     When this function returns true, these functions are supported on the device:
     - PLIB_SPI_MasterEnable
     - PLIB_SPI_SlaveEnable
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The MasterControl feature is supported on the device
     - false - The MasterControl feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsMasterControl (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsBaudRate( SPI_MODULE_ID index )
   Summary:
     Identifies whether the BaudRate feature exists on the SPI module.
   Description:
     This function identifies whether the BaudRate feature is available on the SPI
         module.
     When this function returns true, this function is supported on the device:
     - PLIB_SPI_BaudRateSet
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The BaudRate feature is supported on the device
     - false - The BaudRate feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsBaudRate (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsBusStatus( SPI_MODULE_ID index )
   Summary:
     Identifies whether the BusStatus feature exists on the SPI module.
   Description:
     This function identifies whether the BusStatus feature is available on the
         SPI module.
     When this function returns true, this function is supported on the device:
     - PLIB_SPI_IsBusy
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The BusStatus feature is supported on the device
     - false - The BusStatus feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsBusStatus (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsReadDataSignStatus( SPI_MODULE_ID index )
   Summary:
     Identifies whether the ReadDataSignStatus feature exists on the SPI module.
   Description:
     This function identifies whether the ReadDataSignStatus feature is available
         on the SPI module.
     When this function returns true, this function is supported on the device:
     - PLIB_SPI_ReadDataIsSignExtended
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ReadDataSignStatus feature is supported on the device
     - false - The ReadDataSignStatus feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsReadDataSignStatus (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsSlaveSelectControl( SPI_MODULE_ID index )
   Summary:
     Identifies whether the SlaveSelectControl feature exists on the SPI module.
   Description:
     This function identifies whether the SlaveSelectControl feature is available
         on the SPI module.
     When this function returns true, these functions are supported on the device:
     - PLIB_SPI_SlaveSelectEnable
     - PLIB_SPI_SlaveSelectDisable
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The SlaveSelectControl feature is supported on the device
     - false - The SlaveSelectControl feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsSlaveSelectControl (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsTransmitUnderRunStatus( SPI_MODULE_ID index )
   Summary:
     Identifies whether the TransmitUnderRunStatus feature exists on the SPI module.
   Description:
     This function identifies whether the TransmitUnderRunStatus feature is available
         on the SPI module.
     When this function returns true, these functions are supported on the device:
     - PLIB_SPI_TransmitUnderRunStatusGet
     - PLIB_SPI_TransmitUnderRunStatusClear
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The TransmitUnderRunStatus feature is supported on the device
     - false - The TransmitUnderRunStatus feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsTransmitUnderRunStatus (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsFIFOControl( SPI_MODULE_ID index )
   Summary:
     Identifies whether the FIFOControl feature exists on the SPI module.
   Description:
     This function identifies whether the FIFOControl feature is available on the
         SPI module.
     When this function returns true, these functions are supported on the device:
     - PLIB_SPI_FIFOEnable
     - PLIB_SPI_FIFODisable
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The FIFOControl feature is supported on the device
     - false - The FIFOControl feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsFIFOControl (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsFIFOCount( SPI_MODULE_ID index )
   Summary:
     Identifies whether the FIFOCount feature exists on the SPI module.
   Description:
     This function identifies whether the FIFOCount feature is available on the SPI module.
     When this function returns true, this function is supported on the device:
     - PLIB_SPI_FIFOCountGet
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The FIFOCount feature is supported on the device
     - false - The FIFOCount feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsFIFOCount (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsReceiveFIFOStatus( SPI_MODULE_ID index )
   Summary:
     Identifies whether the ReceiveFIFOStatus feature exists on the SPI module.
   Description:
     This function identifies whether the ReceiveFIFOStatus feature is available
         on the SPI module.
     When this function returns true, this function is supported on the device:
     - PLIB_SPI_ReceiverFIFOIsEmpty
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ReceiveFIFOStatus feature is supported on the device
     - false - The ReceiveFIFOStatus feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsReceiveFIFOStatus (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsFIFOShiftRegisterEmptyStatus( SPI_MODULE_ID index )
   Summary:
     Identifies whether the FIFOShiftRegisterEmptyStatus feature exists on the SPI module.
   Description:
     This function identifies whether the FIFOShiftRegisterEmptyStatus feature is
         available on the SPI module.
     When this function returns true, this function is supported on the device:
     - PLIB_SPI_FIFOShiftRegisterIsEmpty
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The FIFOShiftRegisterEmptyStatus feature is supported on the device
     - false - The FIFOShiftRegisterEmptyStatus feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsFIFOShiftRegisterEmptyStatus (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsFIFOInterruptMode( SPI_MODULE_ID index )
   Summary:
     Identifies whether the FIFOInterruptMode feature exists on the SPI module.
   Description:
     This function identifies whether the FIFOInterruptMode feature is available
         on the SPI module.
     When this function returns true, this function is supported on the device:
     - PLIB_SPI_FIFOInterruptModeSelect
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The FIFOInterruptMode feature is supported on the device
     - false - The FIFOInterruptMode feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsFIFOInterruptMode (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsFramedCommunication( SPI_MODULE_ID index )
   Summary:
     Identifies whether the FramedCommunication feature exists on the SPI module.
   Description:
     This function identifies whether the FramedCommunication feature is available
         on the SPI module.
     When this function returns true, these functions are supported on the device:
     - PLIB_SPI_FramedCommunicationEnable
     - PLIB_SPI_FramedCommunicationDisable
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The FramedCommunication feature is supported on the device
     - false - The FramedCommunication feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsFramedCommunication (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsFrameSyncPulseDirection( SPI_MODULE_ID index )
   Summary:
     Identifies whether the FrameSyncPulseDirection feature exists on the SPI module.
   Description:
     This function identifies whether the FrameSyncPulseDirection feature is available
         on the SPI module.
     When this function returns true, this function is supported on the device:
     - PLIB_SPI_FrameSyncPulseDirectionSelect
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The FrameSyncPulseDirection feature is supported on the device
     - false - The FrameSyncPulseDirection feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsFrameSyncPulseDirection (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsFrameSyncPulsePolarity( SPI_MODULE_ID index )
   Summary:
     Identifies whether the FrameSyncPulsePolarity feature exists on the SPI module.
   Description:
     This function identifies whether the FrameSyncPulsePolarity feature is available
         on the SPI module.
     When this function returns true, this function is supported on the device:
     - PLIB_SPI_FrameSyncPulsePolaritySelect
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The FrameSyncPulsePolarity feature is supported on the device
     - false - The FrameSyncPulsePolarity feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsFrameSyncPulsePolarity (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsFrameSyncPulseEdge( SPI_MODULE_ID index )
   Summary:
     Identifies whether the FrameSyncPulseEdge feature exists on the SPI module.
   Description:
     This function identifies whether the FrameSyncPulseEdge feature is available
         on the SPI module.
     When this function returns true, this function is supported on the device:
     - PLIB_SPI_FrameSyncPulseEdgeSelect
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The FrameSyncPulseEdge feature is supported on the device
     - false - The FrameSyncPulseEdge feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsFrameSyncPulseEdge (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsFrameSyncPulseWidth( SPI_MODULE_ID index )
   Summary:
     Identifies whether the FrameSyncPulseWidth feature exists on the SPI module.
   Description:
     This function identifies whether the FrameSyncPulseWidth feature is available
         on the SPI module.
     When this function returns true, this function is supported on the device:
     - PLIB_SPI_FrameSyncPulseWidthSelect
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The FrameSyncPulseWidth feature is supported on the device
     - false - The FrameSyncPulseWidth feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsFrameSyncPulseWidth (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsFrameSyncPulseCounter( SPI_MODULE_ID index )
   Summary:
     Identifies whether the FrameSyncPulseCounter feature exists on the SPI module.
   Description:
     This function identifies whether the FrameSyncPulseCounter feature is available
         on the SPI module.
     When this function returns true, this function is supported on the device:
     - PLIB_SPI_FrameSyncPulseCounterSelect
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The FrameSyncPulseCounter feature is supported on the device
     - false - The FrameSyncPulseCounter feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsFrameSyncPulseCounter (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsFrameErrorStatus( SPI_MODULE_ID index )
   Summary:
     Identifies whether the FrameErrorStatus feature exists on the SPI module.
   Description:
     This function identifies whether the FrameErrorStatus feature is available on
         the SPI module.
     When this function returns true, these functions are supported on the device:
     - PLIB_SPI_FrameErrorStatusGet
     - PLIB_SPI_FrameErrorStatusClear
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The FrameErrorStatus feature is supported on the device
     - false - The FrameErrorStatus feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsFrameErrorStatus (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsBuffer( SPI_MODULE_ID index )
   Summary:
     Identifies whether the Buffer feature exists on the SPI module.
   Description:
     This function identifies whether the Buffer feature is available on the SPI module.
     When this function returns true, these functions are supported on the device:
     - PLIB_SPI_BufferClear
     - PLIB_SPI_BufferRead
     - PLIB_SPI_BufferWrite
     - PLIB_SPI_BufferAddressGet
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The Buffer feature is supported on the device
     - false - The Buffer feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsBuffer (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsBaudRateClock( SPI_MODULE_ID index )
   Summary:
     Identifies whether the BaudRateClock feature exists on the SPI module.
   Description:
     This function identifies whether the BaudRateClock feature is available on
         the SPI module.
     When this function returns true, this function is supported on the device:
     - PLIB_SPI_BaudRateClockSelect
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The BaudRateClock feature is supported on the device
     - false - The BaudRateClock feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsBaudRateClock (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsErrorInterruptControl( SPI_MODULE_ID index )
   Summary:
     Identifies whether the ErrorInterruptControl feature exists on the SPI module.
   Description:
     This function identifies whether the ErrorInterruptControl feature is available
         on the SPI module.
     When this function returns true, these functions are supported on the device:
     - PLIB_SPI_ErrorInterruptEnable
     - PLIB_SPI_ErrorInterruptDisable
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The ErrorInterruptControl feature is supported on the device
     - false - The ErrorInterruptControl feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsErrorInterruptControl (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsAudioErrorControl( SPI_MODULE_ID index )
   Summary:
     Identifies whether the AudioErrorControl feature exists on the SPI module.
   Description:
     This function identifies whether the AudioErrorControl feature is available
         on the SPI module.
     When this function returns true, these functions are supported on the device:
     - PLIB_SPI_AudioErrorEnable
     - PLIB_SPI_AudioErrorDisable
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The AudioErrorControl feature is supported on the device
     - false - The AudioErrorControl feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsAudioErrorControl (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsAudioProtocolControl( SPI_MODULE_ID index )
   Summary:
     Identifies whether the AudioProtocolControl feature exists on the SPI module.
   Description:
     This function identifies whether the AudioProtocolControl feature is available
         on the SPI module.
     When this function returns true, this function is supported on the device:
     - PLIB_SPI_AudioProtocolEnable
     - PLIB_SPI_AudioProtocolDisable
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The AudioProtocolControl feature is supported on the device
     - false - The AudioProtocolControl feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsAudioProtocolControl (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsAudioTransmitMode( SPI_MODULE_ID index )
   Summary:
     Identifies whether the AudioTransmitMode feature exists on the SPI module.
   Description:
     This function identifies whether the AudioTransmitMode feature is available
         on the SPI module.
     When this function returns true, this function is supported on the device:
     - PLIB_SPI_AudioTransmitModeSelect
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The AudioTransmitMode feature is supported on the device
     - false - The AudioTransmitMode feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsAudioTransmitMode (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_ExistsAudioProtocolMode( SPI_MODULE_ID index )
   Summary:
     Identifies whether the AudioProtocolMode feature exists on the SPI module.
   Description:
     This function identifies whether the AudioProtocolMode feature is available
         on the SPI module.
     When this function returns true, this function is supported on the device:
     - PLIB_SPI_AudioProtocolModeSelect
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The AudioProtocolMode feature is supported on the device
     - false - The AudioProtocolMode feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_ExistsAudioProtocolMode (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_Exists32bitBuffer( SPI_MODULE_ID index )
   Summary:
     Identifies whether the Buffer32bit feature exists on the SPI module.
   Description:
     This function identifies whether the Buffer32bit feature is available on the
         SPI module.
     When this function returns true, these functions are supported on the device:
     - PLIB_SPI_BufferRead32bit
     - PLIB_SPI_BufferWrite32bit
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The Buffer32bit feature is supported on the device
     - false - The Buffer32bit feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_Exists32bitBuffer (
   SPI_MODULE_ID index ) ;
 //******************************************************************************
 /* Function:
     PLIB_SPI_Exists16bitBuffer( SPI_MODULE_ID index )
   Summary:
     Identifies whether the Buffer16bit feature exists on the SPI module.
   Description:
     This function identifies whether the Buffer16bit feature is available on the
         SPI module.
     When this function returns true, these functions are supported on the device:
     - PLIB_SPI_BufferRead16bit
     - PLIB_SPI_BufferWrite16bit
     This operation is atomic.
   Preconditions:
     None.
   Parameters:
     index - Identifier for the device instance
   Returns:
     - true - The Buffer16bit feature is supported on the device
     - false - The Buffer16bit feature is not supported on the device
   Remarks:
     None.
 */

 bool
   PLIB_SPI_Exists16bitBuffer (
   SPI_MODULE_ID index ) ;
 //DOM-IGNORE-BEGIN
 //DOM-IGNORE-END
        // #ifndef _PLIB_SPI_H
 /*******************************************************************************
  End of File
  */

 #endif /*00 C:\microchip\harmony\v2_06\framework\peripheral\spi\plib_spi.h*/
 /*   CLOSE_FILE Include File */

          // SPI PLIB Header
 #include "system/common/sys_common.h"           // Common System Service Definitions
 #include "system/common/sys_module.h"           // Module/Driver Definitions
 #include "system/int/sys_int.h"                 // System Interrupt Definitions
 #include "system/clk/sys_clk.h"
 #include "C:\microchip\harmony\v2_06\framework\system\ports\sys_ports.h"
                                                                          /* LDRA full path */
 // DOM-IGNORE-BEGIN
 // DOM-IGNORE-END
 // *****************************************************************************
 /* SPI Driver Buffer Handle
   Summary:
     Handle identifying a read or write buffer passed to the driver.
   Description:
     A buffer handle value is returned by a call to the DRV_SPI_BufferAddRead()/
     DRV_SPI_BufferAddWrite or DRV_SPI_BufferAddReadWrite() functions.
     This handle is associated with the buffer passed into the function and
     it allows the application to track the completion of the data from (or into)
     that buffer. The buffer handle value returned from the "buffer add" function
     is returned back to the client by the "callback" function registered with
     the driver.
     The buffer handle assigned to a client request expires when the client has
     been notified of the completion of the buffer transfer (after event handler
     function that notifies the client returns) or after the buffer has been
     retired by the driver if no event handler callback was set.
   Remarks:
     None.
 */

 typedef
 uintptr_t
   DRV_SPI_BUFFER_HANDLE ;
 // *****************************************************************************
 /* SPI Driver Invalid Buffer Handle
   Summary:
     Definition of an invalid buffer handle.
   Description:
     This is the definition of an invalid buffer handle. An invalid buffer handle
     is returned by DRV_SPI_BufferAddRead() and DRV_SPI_BufferAddWrite()
     function if the buffer add request was not successful.
   Remarks:
     None.
 */
 #define DRV_SPI_BUFFER_HANDLE_INVALID ( ( DRV_SPI_BUFFER_HANDLE ) ( - 1 ) )
 // *****************************************************************************
 /* SPI Driver Module Index Numbers
   Summary:
     SPI driver index definitions.
   Description:
     These constants provide the SPI driver index definitions.
   Remarks:
     These constants should be used in place of hard-coded numeric literals.
     These values should be passed into the DRV_SPI_Initialize and
     DRV_SPI_Open functions to identify the driver instance in use.
 */
 #define DRV_SPI_INDEX_0 0
 #define DRV_SPI_INDEX_1 1
 #define DRV_SPI_INDEX_2 2
 #define DRV_SPI_INDEX_3 3
 #define DRV_SPI_INDEX_4 4
 #define DRV_SPI_INDEX_5 5
 // *****************************************************************************
 /* SPI Driver Module Index Count
   Summary:
     Number of valid SPI driver indices.
   Description:
     This constant identifies the number of valid SPI driver indices.
   Remarks:
     This constant should be used in place of hard-coded numeric literals.
     This value is derived from device-specific header files defined as part
     of the peripheral libraries.
 */
 #define DRV_SPI_INDEX_COUNT SPI_NUMBER_OF_MODULES
 // *****************************************************************************
 /* SPI Clock Mode Selection
   Summary:
     Identifies the various clock modes of the SPI module.
   Description:
     This enumeration identifies the various clock modes of the SPI module.
   Remarks:
     None.
 */

 typedef
   enum
   {
     /* SPI Clock Mode 0:
         - Idle State of the clock is Low
         - Serial Output Data (SDO) Changed on Rising Edge of the clock
         - Serial Input Data (SDI) Sampled on Falling Edge of the clock */
     DRV_SPI_CLOCK_MODE_IDLE_LOW_EDGE_RISE
         /*DOM-IGNORE-BEGIN*/
     = 0                          /*DOM-IGNORE-END*/
     ,
     /* SPI Clock Mode 1:
         - Idle State of the clock is Low
         - Serial Output Data (SDO) Changes on Falling Edge of the clock
         - Serial Input Data (SDI) Sampled on Rising Edge of the clock */
     DRV_SPI_CLOCK_MODE_IDLE_LOW_EDGE_FALL
         /*DOM-IGNORE-BEGIN*/
     = 1                          /*DOM-IGNORE-END*/
     ,
     /* SPI Clock Mode 2:
         - Idle State of the clock is High
         - Serial Output Data (SDO) Changes on Falling Edge of the clock
         - Serial Input Data (SDI) Sampled on Rising Edge of the clock */
     DRV_SPI_CLOCK_MODE_IDLE_HIGH_EDGE_FALL
         /*DOM-IGNORE-BEGIN*/
     = 2                          /*DOM-IGNORE-END*/
     ,
     /* SPI Clock Mode 3:
         - Idle State of the clock is High
         - Serial Output Data (SDO) Changes on Rising Edge of the clock
         - Serial Input Data (SDI) Sampled on Falling Edge of the clock */
     DRV_SPI_CLOCK_MODE_IDLE_HIGH_EDGE_RISE
         /*DOM-IGNORE-BEGIN*/
     = 3                          /*DOM-IGNORE-END*/
   } DRV_SPI_CLOCK_MODE ;
 // *****************************************************************************
 /* SPI Buffer Type Selection
   Summary:
     Identifies the various buffer types of the SPI module.
   Description:
     This enumeration identifies the various buffer types of the SPI module.
   Remarks:
     None.
 */

 typedef
   enum
   {
     /* SPI Buffer Type Standard */
     DRV_SPI_BUFFER_TYPE_STANDARD
         /*DOM-IGNORE-BEGIN*/
     = 0                          /*DOM-IGNORE-END*/
     ,
     /* SPI Enhanced Buffer Type */
     DRV_SPI_BUFFER_TYPE_ENHANCED
         /*DOM-IGNORE-BEGIN*/
     = 1                          /*DOM-IGNORE-END*/
   } DRV_SPI_BUFFER_TYPE ;
 // *****************************************************************************
 /* SPI Protocols Enumeration
   Summary:
     Identifies the various protocols of the SPI module.
   Description:
     This enumeration identifies the various protocols of the SPI module.
   Remarks:
     None.
 */

 typedef
   enum
   {
     /* SPI Protocol Type Standard */
     DRV_SPI_PROTOCOL_TYPE_STANDARD
         /*DOM-IGNORE-BEGIN*/
     = 0                          /*DOM-IGNORE-END*/
     ,
     /* SPI Protocol Type Framed */
     DRV_SPI_PROTOCOL_TYPE_FRAMED
         /*DOM-IGNORE-BEGIN*/
     = 1                          /*DOM-IGNORE-END*/
     ,
     /*SPI Protocol Type Audio*/
     DRV_SPI_PROTOCOL_TYPE_AUDIO
         /*DOM-IGNORE-BEGIN*/
     = 2                          /*DOM-IGNORE-END*/
   } DRV_SPI_PROTOCOL_TYPE ;
 // *****************************************************************************
 /* SPI Driver Buffer Events
    Summary
     Identifies the possible events that can result from a buffer add request.
    Description
     This enumeration identifies the possible events that can result from a
     buffer add request caused by the client calling either
     DRV_SPI_BufferAddRead2 or DRV_SPI_BufferAddWrite2 or similar functions.
    Remarks:
     One of these values is passed in the "event" parameter of the event
     handling callback function that the client registered during buffer add
     requests.
 */

 typedef
   enum
   {
     /* Buffer is pending to get processed */
     DRV_SPI_BUFFER_EVENT_PENDING ,
     /* Buffer is being processed */
     DRV_SPI_BUFFER_EVENT_PROCESSING ,
     /* All data from or to the buffer was transferred successfully. */
     DRV_SPI_BUFFER_EVENT_COMPLETE ,
     /* There was an error while processing the buffer transfer request. */
     DRV_SPI_BUFFER_EVENT_ERROR
   } DRV_SPI_BUFFER_EVENT ;
 // *****************************************************************************
 /* SPI Usage Modes Enumeration
   Summary:
     Identifies the various usage modes of the SPI module.
   Description:
     This enumeration identifies the various usage modes of the SPI module.
   Remarks:
     None.
 */

 typedef
   enum
   {
     /* SPI Mode Master */
     DRV_SPI_MODE_MASTER
         /*DOM-IGNORE-BEGIN*/
     = 0                          /*DOM-IGNORE-END*/
     ,
     /* SPI Mode Slave */
     DRV_SPI_MODE_SLAVE
         /*DOM-IGNORE-BEGIN*/
     = 1                          /*DOM-IGNORE-END*/
   } DRV_SPI_MODE ;
 // *****************************************************************************
 /* SPI Task Modes Enumeration
   Summary:
     Identifies the various modes of how the tasks function will be run.
   Description:
     This enumeration identifies the various tasks mode
   Remarks:
     None.
 */

 typedef
   enum
   {
     /* Task is configured to run in polled mode */
     DRV_SPI_TASK_MODE_POLLED
         /*DOM-IGNORE-BEGIN*/
     = 0                          /*DOM-IGNORE-END*/
     ,
     /* Task is configured to run in interrupt mode */
     DRV_SPI_TASK_MODE_ISR
         /*DOM-IGNORE-BEGIN*/
     = 1                          /*DOM-IGNORE-END*/
   } DRV_SPI_TASK_MODE ;
 // *****************************************************************************
 /* SPI Driver Buffer Event Handler Function Pointer
    Summary:
     Pointer to a SPI Driver Buffer Event handler function
    Description:
     This data type defines the required function signature for the SPI driver
     buffer event handling callback function. A client must register a pointer
     to a buffer event handling function who's function signature (parameter
     and return value types) match the types specified by this function pointer
     in order to receive buffer related event calls back from the driver.
     The parameters and return values and return value are described here and
     a partial example implementation is provided.
   Parameters:
     event - Identifies the type of event
     bufferHandle - Handle identifying the buffer to which the vent relates
         context - Value identifying the context of the application that
               registered the event handling function.
   Returns:
     None.
   Example:
     <code>
     void APP_MyBufferEventHandler( DRV_SPI_BUFFER_EVENT event,
                                    DRV_SPI_BUFFER_HANDLE bufferHandle,
                                    uintptr_t context )
     {
         MY_APP_DATA_STRUCT pAppData = (MY_APP_DATA_STRUCT) context;
         switch(event)
         {
             case DRV_SPI_BUFFER_EVENT_COMPLETE:
                 // Handle the completed buffer.
                 break;
             case DRV_SPI_BUFFER_EVENT_ERROR:
             default:
                 // Handle error.
                 break;
         }
     }
     </code>
   Remarks:
     If the event is DRV_SPI_BUFFER_EVENT_COMPLETE, it means that the data was
     transferred successfully.
     If the event is DRV_SPI_BUFFER_EVENT_ERROR, it means that the data was
     not transferred successfully.
     The bufferHandle parameter contains the buffer handle of the buffer that
     failed.
     The context parameter contains the a handle to the client context,
     provided at the time the event handling function registration.
     This context handle value is passed back to the client as the "context"
     parameter. It can be any value necessary to identify the client context
     or instance (such as a pointer to the client's data) instance of the
     client that made the buffer add request.
     The event handler function executes in an interrupt context when the driver
     is configured for interrupt mode operation. It is recommended of the
     application to not perform process intensive operations with in this
     function.
 */

 typedef
 void ( * DRV_SPI_BUFFER_EVENT_HANDLER ) ( DRV_SPI_BUFFER_EVENT event ,
 DRV_SPI_BUFFER_HANDLE bufferHandle ,
 void * context ) ;
 // *****************************************************************************
 /* SPI Driver Initialization Data
   Summary:
     Defines the data required to initialize or reinitialize the SPI driver
   Description:
     This data type defines the data required to initialize or reinitialize the
     SPI driver. If the driver is built statically, the members of this data
     structure are statically over-ridden by static override definitions in the
     system_config.h file.
   Remarks:
     None.
 */

 typedef
 struct _DRV_SPI_INIT
 {
     /* System module initialization */
   SYS_MODULE_INIT moduleInit ;
     /* Identifies peripheral (PLIB-level) ID */
   SPI_MODULE_ID spiId ;
     /* SPI Task Mode Type*/
   DRV_SPI_TASK_MODE taskMode ;
     /* SPI Usage Mode Type */
   DRV_SPI_MODE spiMode ;
     /* Allow SPI to run when CPU goes to idle mode*/
   bool allowIdleRun ;
     /* SPI Protocol Type */
   DRV_SPI_PROTOCOL_TYPE spiProtocolType ;
     /* SPI Slave Mode SSx Pin Select */
   bool spiSlaveSSPin ;
     /* Framed mode Sync Pulse*/
   SPI_FRAME_SYNC_PULSE frameSyncPulse ;
     /* Framed Mode pulse polarity*/
   SPI_FRAME_PULSE_POLARITY framePulsePolarity ;
     /* Framed Mode Pulse Direction*/
   SPI_FRAME_PULSE_DIRECTION framePulseDirection ;
     /* Framed mode Pulse Edge*/
   SPI_FRAME_PULSE_EDGE framePulseEdge ;
     /* Framed Mode Pulse width */
   SPI_FRAME_PULSE_WIDTH framePulseWidth ;
     /* Audio mode transmit mode*/
   SPI_AUDIO_TRANSMIT_MODE audioTransmitMode ;
     /* Audio mode protocol mode*/
   SPI_AUDIO_PROTOCOL audioProtocolMode ;
     /* Communication Width */
   SPI_COMMUNICATION_WIDTH commWidth ;
     /* SPI clock source which generates required baud rate.
        It can be either PBCLK or Reference Clock */
   SPI_BAUD_RATE_CLOCK baudClockSource ;
     /* when Baud rate clock source is peripheral clock, then this element is
        used to define which peripheral bus clock is used for this particular
        SPI instance. */
   CLK_BUSES_PERIPHERAL spiClk ;
     /* Baud Rate Value */
   uint32_t baudRate ;
     /* SPI Buffer Type */
   DRV_SPI_BUFFER_TYPE bufferType ;
     /* SPI Clock mode */
   DRV_SPI_CLOCK_MODE clockMode ;
     /* SPI Input Sample Phase Selection */
   SPI_INPUT_SAMPLING_PHASE inputSamplePhase ;
     /* Transmit/Receive or Transmit Interrupt Source for SPI module */
   INT_SOURCE txInterruptSource ;
     /* Receive Interrupt Source for SPI module */
   INT_SOURCE rxInterruptSource ;
     /* Error Interrupt Source for SPI module */
   INT_SOURCE errInterruptSource ;
     /* While using standard buffer and polled mode how many transfers to do
        before yielding to other tasks*/
   uint8_t numTrfsSmPolled ;
     /* Dummy byte value which will be used for dummy transmission */
   uint32_t dummyByteValue ;
     /* This is the buffer queue size. This is the maximum
        number of transfer requests that driver will queue. */
   uint8_t queueSize ;
     /* This controls the minimum number of jobs that the driver will be able
        to accept without running out of memory. The driver will reserve this
        number of jobs from the global SPI queue so that it will always be available*/
   uint8_t jobQueueReserveSize ;
         /* This callback is fired when an operation is about to start on the
            SPI bus. This allows the user to set any pins that need to be set.
            This callback may be called from an ISR so should not include OSAL
            calls. The context parameter is the same one passed into the
            BufferAddRead, BufferAddWrite, BufferAddWriteRead function.
          */
   DRV_SPI_BUFFER_EVENT_HANDLER operationStarting ;
         /* This callback is fired when an operation has just completed on the
            SPI bus. This allows the user to set any pins that need to be set.
            This callback may be called from an ISR so should not include OSAL
            calls. The context parameter is the same one passed into the
            BufferAddRead, BufferAddWrite, BufferAddWriteRead function.
          */
   DRV_SPI_BUFFER_EVENT_HANDLER operationEnded ;
 } DRV_SPI_INIT ;
 // *****************************************************************************
 /* SPI Driver Client Specific Configuration
   Summary:
     Defines the data that can be changed per client.
   Description:
     This data type defines the data can be configured per client. This data can
     be per client, and overrides the configuration data contained inside of
     DRV_SPI_INIT.
   Remarks:
     None.
 */

 typedef
 struct _DRV_SPI_CLIENT_DATA
 {
     /* Baud Rate Value */
   uint32_t baudRate ;
     /* This callback is fired when an operation is about to start on the
        SPI bus. This allows the user to set any pins that need to be set.
        This callback may be called from an ISR so should not include OSAL
        calls. The context parameter is the same one passed into the
        BufferAddRead, BufferAddWrite, BufferAddWriteRead function.
      */
   DRV_SPI_BUFFER_EVENT_HANDLER operationStarting ;
     /* This callback is fired when an operation has just completed on the
        SPI bus. This allows the user to set any pins that need to be set.
        This callback may be called from an ISR so should not include OSAL
        calls. The context parameter is the same one passed into the
        BufferAddRead, BufferAddWrite, BufferAddWriteRead function.
      */
   DRV_SPI_BUFFER_EVENT_HANDLER operationEnded ;
 } DRV_SPI_CLIENT_DATA ;
 //DOM-IGNORE-BEGIN
 //DOM-IGNORE-END
        // #ifndef _DRV_SPI_DEFINITIONS_H
 /*******************************************************************************
  End of File
 */

 #endif /*00 C:\microchip\harmony\v2_06\framework\driver\spi\drv_spi_definitions.h*/
 /*   CLOSE_FILE Include File */

 // DOM-IGNORE-BEGIN
 // DOM-IGNORE-END
 // *****************************************************************************
 // *****************************************************************************
 // Section: Interface Routines - System Level
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* Function:
       SYS_MODULE_OBJ DRV_SPI_Initialize( const SYS_MODULE_INDEX index,
                                            const SYS_MODULE_INIT * const init )
   Summary:
     Initializes the SPI instance for the specified driver index.
         <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This routine initializes the SPI driver instance for the specified driver
     index, making it ready for clients to open and use it. The initialization
     data is specified by the 'init' parameter. The initialization may fail if the
     number of driver objects allocated are insufficient or if the specified
     driver instance is already initialized. The driver instance index is
     independent of the SPI module ID. For example, driver instance 0 can be
     assigned to SPI2. If the driver is built statically, then some of the
     initialization parameters are overridden by configuration macros. Refer to
     the description of the DRV_SPI_INIT data structure for more details on
     which members on this data structure are overridden.
   Precondition:
     None.
   Parameters:
     index - Identifier for the instance to be initialized. Please note this
              is not the SPI id. The hardware SPI id is set in the initialization
              structure. This is the index of the driver index to use.
     init - Pointer to a data structure containing any data necessary to
              initialize the driver. If this pointer is NULL, the driver
              uses the static initialization override macros for each
              member of the initialization data structure.
   Returns:
     - If successful - returns a valid handle to a driver instance object
     - If unsuccessful - returns SYS_MODULE_OBJ_INVALID
   Example:
     <code>
     DRV_SPI_INIT init;
     SYS_MODULE_OBJ objectHandle;
     // Populate the SPI initialization structure
     init.spiId = SPI_ID_1,
     init.taskMode = DRV_SPI_TASK_MODE_ISR,
     init.spiMode = DRV_SPI_MODE_MASTER,
     init.allowIdleRun = false,
     init.spiProtocolType = DRV_SPI_PROTOCOL_TYPE_STANDARD,
     init.commWidth = SPI_COMMUNICATION_WIDTH_8BITS,
     init.baudClockSource = SPI_BAUD_RATE_PBCLK_CLOCK;
     init.spiClk = CLK_BUS_PERIPHERAL_2,
     init.baudRate = 10000000,
     init.bufferType = DRV_SPI_BUFFER_TYPE_ENHANCED,
     init.clockMode = DRV_SPI_CLOCK_MODE_IDLE_LOW_EDGE_FALL,
     init.inputSamplePhase = SPI_INPUT_SAMPLING_PHASE_IN_MIDDLE,
     init.txInterruptSource = INT_SOURCE_SPI_1_TRANSMIT,
     init.rxInterruptSource = INT_SOURCE_SPI_1_RECEIVE,
     init.errInterruptSource = INT_SOURCE_SPI_1_ERROR,
     init.dummyByteValue = 0xFF,
     init.queueSize = 10,
     init.jobQueueReserveSize = 1,
     objectHandle = DRV_SPI_Initialize(DRV_SPI_INDEX_1, (SYS_MODULE_INIT*)usartInitData);
     if (SYS_MODULE_OBJ_INVALID == objectHandle)
     {
         // Handle error
     }
     </code>
   Remarks:
     This routine must be called before any other SPI routine is called.
     This routine should only be called once during system initialization
     unless DRV_SPI_Deinitialize is called to deinitialize the driver
     instance. This routine will NEVER block for hardware access.
 */

 SYS_MODULE_OBJ
   DRV_SPI_Initialize (
   const SYS_MODULE_INDEX index ,
   const SYS_MODULE_INIT * const init ) ;
 //*************************************************************************
 /* Function:
        void DRV_SPI_Deinitialize ( SYS_MODULE_OBJ object )
   Summary:
     Deinitializes the specified instance of the SPI driver module.
         <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     Deinitializes the specified instance of the SPI driver module,
     disabling its operation (and any hardware) and invalidates all of the
     internal data.
   Precondition:
     Function DRV_SPI_Initialize must have been called before calling this
     routine and a valid SYS_MODULE_OBJ must have been returned.
   Parameters:
     object - Driver object handle, returned from DRV_SPI_Initialize
   Returns:
     None.
   Example:
     <code>
     SYS_MODULE_OBJ object; // Returned from DRV_SPI_Initialize
     SYS_STATUS status;
     DRV_SPI_Deinitialize ( object );
     status = DRV_SPI_Status( object );
     if( SYS_MODULE_UNINITIALIZED == status )
     {
         // Check again later if you need to know
         // when the driver is deinitialized.
     }
     </code>
   Remarks:
     Once the Initialize operation has been called, the De-initialize
     operation must be called before the Initialize operation can be called
     again.
     This function will NEVER block waiting for hardware. If the operation
     requires time to allow the hardware to complete, this will be reported
     by the DRV_SPI_Status operation. The system has to use DRV_SPI_Status
     to find out when the module is in the ready state.
 */

 void
   DRV_SPI_Deinitialize (
   SYS_MODULE_OBJ object ) ;
 //**************************************************************************
 /* Function:
        SYS_STATUS DRV_SPI_Status ( SYS_MODULE_OBJ object )
   Summary:
     Provides the current status of the SPI driver module.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This function provides the current status of the SPI driver module.
   Precondition:
     The DRV_SPI_Initialize function must have been called before calling
     this function.
   Parameters:
     object - Driver object handle, returned from DRV_SPI_Initialize
   Returns:
     - SYS_STATUS_READY - Indicates that the driver is busy with a previous
     system level operation and cannot start another
   Example:
     <code>
     SYS_MODULE_OBJ object; // Returned from DRV_SPI_Initialize
     SYS_STATUS status;
     status = DRV_SPI_Status( object );
     if( SYS_STATUS_READY != status )
     {
         // Handle error
     }
     </code>
   Remarks:
     Any value greater than SYS_STATUS_READY is also a normal running state
     in which the driver is ready to accept new operations.
     SYS_MODULE_UNINITIALIZED - Indicates that the driver has been
     deinitialized
     This value is less than SYS_STATUS_ERROR.
     This function can be used to determine when any of the driver's module
     level operations has completed.
     If the status operation returns SYS_STATUS_BUSY, the previous operation
     has not yet completed. Once the status operation returns
     SYS_STATUS_READY, any previous operations have completed.
     The value of SYS_STATUS_ERROR is negative (-1). Any value less than
     that is also an error state.
     This function will NEVER block waiting for hardware.
     If the Status operation returns an error value, the error may be
     cleared by calling the reinitialize operation. If that fails, the
     deinitialize operation will need to be called, followed by the
     initialize operation to return to normal operations.
 */

 SYS_STATUS
   DRV_SPI_Status (
   SYS_MODULE_OBJ object ) ;
 // *****************************************************************************
 /* Function:
     void DRV_SPI_Tasks ( SYS_MODULE_OBJ object );
   Summary:
     Maintains the driver's state machine and implements its ISR.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
         This routine is used to maintain the driver's internal state
         machine and implement its transmit ISR for interrupt-driven implementations.
         In polling mode, this function should be called from the SYS_Tasks()
         function. In interrupt mode, this function should be called in the transmit
         interrupt service routine of the USART that is associated with this USART
         driver hardware instance.
   Precondition:
     The DRV_SPI_Initialize routine must have been called for the specified
     SPI driver instance.
   Parameters:
     object - Object handle for the specified driver instance (returned from
                   DRV_SPI_Initialize)
   Returns:
     None.
   Example:
     <code>
     SYS_MODULE_OBJ object; // Returned from DRV_SPI_Initialize
     while( true )
     {
         DRV_SPI_Tasks ( object );
         // Do other tasks
     }
     </code>
   Remarks:
     This function is normally not called directly by an application. It is
     called by the system's Tasks routine (SYS_Tasks) or by the appropriate raw
     ISR.
     This function may execute in an ISR context and will never block or access any
     resources that may cause it to block.
 */

 void
   DRV_SPI_Tasks (
   SYS_MODULE_OBJ object ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: Interface Routines - Client Level
 // *****************************************************************************
 // *****************************************************************************
 //**************************************************************************
 /* Function:
        DRV_HANDLE DRV_SPI_Open ( const SYS_MODULE_INDEX drvIndex,
                                 const DRV_IO_INTENT ioIntent )
   Summary:
     Opens the specified SPI driver instance and returns a handle to it.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This routine opens the specified SPI driver instance and provides a
     handle that must be provided to all other client-level operations to
     identify the caller and the instance of the driver. The ioIntent
     parameter defines how the client interacts with this driver instance.
     If ioIntent is DRV_IO_INTENT_READ, the client will only be read from
     the driver. If ioIntent is DRV_IO_INTENT_WRITE, the client will only be
     able to write to the driver. If the ioIntent in
     DRV_IO_INTENT_READWRITE, the client will be able to do both, read and
     write.
     Specifying a DRV_IO_INTENT_EXCLUSIVE will cause the driver to provide
     exclusive access to this client. The driver cannot be opened by any
     other client.
   Precondition:
     The DRV_SPI_Initialize function must have been called before calling
     this function.
   Parameters:
     drvIndex - Index of the driver initialized with DRV_SPI_Initialize().
                 Please note this is not the SPI ID.
     ioIntent - Zero or more of the values from the enumeration
                 DRV_IO_INTENT ORed together to indicate the intended use of
                 the driver
   Returns:
     If successful, the routine returns a valid open-instance handle (a
     number identifying both the caller and the module instance).
     If an error occurs, the return value is DRV_HANDLE_INVALID. An error
     can occur when the following is true:
       * if the number of client objects allocated via
         DRV_SPI_INSTANCES_NUMBER is insufficient
       * if the client is trying to open the driver but driver has been
         opened exclusively by another client
       * if the driver hardware instance being opened is not initialized or
         is invalid
   Example:
     <code>
     DRV_HANDLE handle;
     handle = DRV_SPI_Open( DRV_SPI_INDEX_0, DRV_IO_INTENT_EXCLUSIVE );
     if( DRV_HANDLE_INVALID == handle )
     {
         // Unable to open the driver
     }
     </code>
   Remarks:
     The handle returned is valid until the DRV_SPI_Close routine is
     called. This routine will NEVER block waiting for hardware. If the
     requested intent flags are not supported, the routine will return
     DRV_HANDLE_INVALID. This function is thread safe in a RTOS application.
     It should not be called in an ISR.
 */

 DRV_HANDLE
   DRV_SPI_Open (
   const SYS_MODULE_INDEX drvIndex ,
   const DRV_IO_INTENT ioIntent ) ;
 //**************************************************************************
 /* Function:
        int32_t DRV_SPI_ClientConfigure ( DRV_HANDLE handle,
                                 const DRV_SPI_CLIENT_DATA * cfgData )
   Summary:
     Configures a SPI client with specific data.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This routine takes a DRV_SPI_CLIENT_DATA structure and sets client specific options.
     Whenever a new SPI job is started these values will be used. Passing in NULL will
     reset the client back to configuration parameters passed to driver initialization.
     A zero in any of the structure elements will reset that specific configuration back
     to the driver default.
   Precondition:
     The DRV_SPI_Open function must have been called before calling
     this function.
   Parameters:
     handle - handle of the client returned by DRV_SPI_Open.
     cfgData - Client-specific configuration data.
   Returns:
     - If successful - the routing will return greater than or equal to zero
     - If an error occurs - the return value is negative
 */

 int32_t
   DRV_SPI_ClientConfigure (
   DRV_HANDLE handle ,
   const DRV_SPI_CLIENT_DATA * cfgData ) ;
 // *****************************************************************************
 /* Function:
     void DRV_SPI_Close ( DRV_HANDLE handle )
   Summary:
     Closes an opened instance of the SPI driver.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This function closes an opened instance of the SPI driver, invalidating the
     handle.
   Precondition:
     The DRV_SPI_Initialize routine must have been called for the specified
     SPI driver instance.
     DRV_SPI_Open must have been called to obtain a valid opened device handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                    open routine
   Returns:
     None.
   Example:
     <code>
     DRV_HANDLE handle; // Returned from DRV_SPI_Open
     DRV_SPI_Close ( handle );
     </code>
   Remarks:
         After calling this routine, the handle passed in "handle" must not be used
     with any of the remaining driver routines. A new handle must be obtained by
     calling DRV_SPI_Open before the caller may use the driver again. This
     function is thread safe in a RTOS application.
     Note:
     Usually there is no need for the driver client to verify that the Close
     operation has completed.
 */

 void
   DRV_SPI_Close (
   DRV_HANDLE handle ) ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: Interface Routines - Client level Read & Write APIs
 // *****************************************************************************
 // *****************************************************************************
 /* These are non-blocking APIs. It doesn't wait until the operation gets
    finished. The actual operation will happen it the task routine. The status of
    this operation can be monitored using DRV_SPI_BufferStatus function. In
    polling mode, User must ensure that the code gets time to execute the task
    routine. */
 //*******************************************************************************
 /* Function:
         DRV_SPI_BUFFER_HANDLE DRV_SPI_BufferAddRead ( DRV_HANDLE handle, void *rxBuffer,
                                        size_t size, DRV_SPI_BUFFER_EVENT_HANDLER completeCB,
                                               void * context )
   Summary:
     Registers a buffer for a read operation. Actual transfer will happen in
     the Task function.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     Registers a buffer for a read operation. Actual transfer will happen in
     the Task function. The status of this operation can be monitored using
     DRV_SPI_BufferStatus function. A optional callback can also be
     provided that will be called when the operation is complete.
   Precondition:
     The DRV_SPI_Initialize routine must have been called for the specified
     SPI driver instance.
     DRV_SPI_Open must have been called to obtain a valid opened device
     handle.
     DRV_IO_INTENT_READ or DRV_IO_INTENT_READWRITE must have been specified
     in the DRV_SPI_Open call.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                 open routine
         rxBuffer - The buffer to which the data should be written to.
         size - Number of bytes to be read from the SPI bus.
     completeCB - Pointer to a function to be called when this queued operation is complete.
     context - unused by the driver but this is passed to the callback when it is called.
   Returns:
     If the buffer add request is successful, a valid buffer handle is returned.
     If request is not queued up, DRV_SPI_BUFFER_HANDLE_INVALID is returned.
   Example:
     <code>
     DRV_HANDLE handle; // Returned from DRV_SPI_Open
     char myBuffer[MY_BUFFER_SIZE], state = 0;
         DRV_SPI_BUFFER_HANDLE bufferHandle;
     switch ( state )
     {
          case 0:
           bufferHandle = DRV_SPI_BufferAddRead( handle, myBuffer, 10, NULL, NULL );
             if(bufferHandle != DRV_SPI_BUFFER_HANDLE_INVALID )
             {
                 state++;
             }
           break;
          case 1:
           if(DRV_SPI_BufferStatus(bufferHandle) == DRV_SPI_BUFFER_EVENT_COMPLETE)
           {
            state++;
            // All transmitter data has been sent successfully.
           }
           break;
         }
     </code>
   Remarks:
     This API will be deprecated soon, so avoid using it. Use "DRV_SPI_BufferAddRead2"
     instead of it.
  */

 DRV_SPI_BUFFER_HANDLE
   DRV_SPI_BufferAddRead (
   DRV_HANDLE handle ,
   void * rxBuffer ,
   size_t size ,
   DRV_SPI_BUFFER_EVENT_HANDLER completeCB ,
   void * context ) ;
 //*******************************************************************************
 /* Function:
         DRV_SPI_BUFFER_HANDLE DRV_SPI_BufferAddWrite ( DRV_HANDLE handle, void *txBuffer,
                                        size_t size, DRV_SPI_BUFFER_EVENT_HANDLER completeCB,
                                               void * context )
   Summary:
     Registers a buffer for a write operation. Actual transfer will happen
     in the Task function.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     Registers a buffer for a write operation. Actual transfer will happen
     in the Task function. The status of this operation can be monitored
     using DRV_SPI_BufferStatus function. A optional callback can also be
     provided that will be called when the operation is complete.
   Precondition:
     The DRV_SPI_Initialize routine must have been called for the specified
     SPI driver instance.
     DRV_SPI_Open must have been called to obtain a valid opened device
     handle.
     DRV_IO_INTENT_WRITE or DRV_IO_INTENT_READWRITE must have been specified
     in the DRV_SPI_Open call.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                 open routine
     txBuffer - The buffer which hold the data.
     size - Number of bytes to be written to the SPI bus.
     completeCB - Pointer to a function to be called when this queued operation is complete
     context - unused by the driver but this is passed to the callback when it is called
   Returns:
     If the buffer add request is successful, a valid buffer handle is returned.
     If request is not queued up, DRV_SPI_BUFFER_HANDLE_INVALID is returned.
   Example:
     <code>
     DRV_HANDLE handle; // Returned from DRV_SPI_Open
         char myBuffer[MY_BUFFER_SIZE], state = 0;
         DRV_SPI_BUFFER_HANDLE bufferHandle;
         switch ( state )
         {
          case 0:
           bufferHandle = DRV_SPI_BufferAddWrite( handle, myBuffer, 10, NULL, NULL );
             if(bufferHandle != DRV_SPI_BUFFER_HANDLE_INVALID )
             {
                 state++;
             }
           break;
          case 1:
           if(DRV_SPI_BufferStatus(bufferHandle) == DRV_SPI_BUFFER_EVENT_COMPLETE)
           {
            state++;
            // All transmitter data has been sent successfully.
           }
           break;
         }
     </code>
   Remarks:
     This API will be deprecated soon, so avoid using it. Use "DRV_SPI_BufferAddWrite2"
     instead of it.
 */

 DRV_SPI_BUFFER_HANDLE
   DRV_SPI_BufferAddWrite (
   DRV_HANDLE handle ,
   void * txBuffer ,
   size_t size ,
   DRV_SPI_BUFFER_EVENT_HANDLER completeCB ,
   void * context ) ;
 //*******************************************************************************
 /* Function:
        DRV_SPI_BUFFER_HANDLE DRV_SPI_BufferAddWriteRead( DRV_HANDLE handle,
             void *txBuffer, void *rxBuffer, size_t size, )
   Summary:
     Registers a buffer for a read and write operation. Actual transfer will
     happen in the Task function.
         <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     Registers a buffer for a read and write operation. Actual transfer will
     happen in the Task function. The status of this operation can be
     monitored using DRV_SPI_BufferStatus function. A optional callback can also be
     provided that will be called when the operation is complete.
   Precondition:
     The DRV_SPI_Initialize routine must have been called for the specified
     SPI driver instance.
     DRV_SPI_Open must have been called to obtain a valid opened device
     handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                 open routine
     txBuffer - The buffer which hold the data.
     txSize - Number of bytes to be written to the SPI bus.
     rxBuffer - The buffer to which the data should be written to.
     rxSize - Number of bytes to be read from the SPI bus
     completeCB - Pointer to a function to be called when this queued operation is complete
     context - unused by the driver but this is passed to the callback when it is called
   Returns:
     If the buffer add request is successful, a valid buffer handle is returned.
     If request is not queued up, DRV_SPI_BUFFER_HANDLE_INVALID is returned.
   Example:
         <code>
         DRV_HANDLE handle; // Returned from DRV_SPI_Open
         char myReadBuffer[MY_BUFFER_SIZE], myWriteBuffer[MY_BUFFER_SIZE], state = 0;
         DRV_SPI_BUFFER_HANDLE bufferHandle;
         switch ( state )
         {
          case 0:
           bufferHandle = DRV_SPI_BufferAddWriteRead( handle, myWriteBuffer, 10, myReadBuffer, 10, NULL, NULL );
             if(bufferHandle != DRV_SPI_BUFFER_HANDLE_INVALID )
             {
                 state++;
             }
           break;
          case 1:
           if(DRV_SPI_BufferStatus(bufferHandle) == DRV_SPI_BUFFER_EVENT_COMPLETE)
           {
            state++;
            // All transmitter data has been sent successfully.
           }
           break;
         }
         </code>
   Remarks:
     This API will be deprecated soon, so avoid using it. Use "DRV_SPI_BufferAddWriteRead2"
     instead of it.
 */

 DRV_SPI_BUFFER_HANDLE
   DRV_SPI_BufferAddWriteRead (
   DRV_HANDLE handle ,
   void * txBuffer ,
   size_t txSize ,
   void * rxBuffer ,
   size_t rxSize ,
   DRV_SPI_BUFFER_EVENT_HANDLER completeCB ,
   void * context ) ;
 //*******************************************************************************
 /* Function:
         DRV_SPI_BUFFER_HANDLE DRV_SPI_BufferAddRead2 ( DRV_HANDLE handle, void *rxBuffer,
                                        size_t size, DRV_SPI_BUFFER_EVENT_HANDLER completeCB,
                                               void * context, DRV_SPI_BUFFER_HANDLE * jobHandle )
   Summary:
     Registers a buffer for a read operation. Actual transfer will happen in
     the Task function.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     Registers a buffer for a read operation. Actual transfer will happen in
     the Task function. The status of this operation can be monitored using
     DRV_SPI_BufferStatus function. A optional callback can also be
     provided that will be called when the operation is complete.
   Precondition:
     The DRV_SPI_Initialize routine must have been called for the specified
     SPI driver instance.
     DRV_SPI_Open must have been called to obtain a valid opened device
     handle.
     DRV_IO_INTENT_READ or DRV_IO_INTENT_READWRITE must have been specified
     in the DRV_SPI_Open call.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                 open routine
         rxBuffer - The buffer to which the data should be written to.
         size - Number of bytes to be read from the SPI bus.
     completeCB - Pointer to a function to be called when this queued operation is complete
     context - unused by the driver but this is passed to the callback when it is called
     jobHandle - pointer to the buffer handle, this will be set before the function returns and can be used in the ISR callback.
   Returns:
     If the buffer add request is successful, a valid buffer handle is returned.
     If request is not queued up, DRV_SPI_BUFFER_HANDLE_INVALID is returned.
   Example:
     <code>
     DRV_HANDLE handle; // Returned from DRV_SPI_Open
     char myBuffer[MY_BUFFER_SIZE], state = 0;
         DRV_SPI_BUFFER_HANDLE bufferHandle, bufferHandle2;
     switch ( state )
     {
          case 0:
           bufferHandle = DRV_SPI_BufferAddRead2( handle, myBuffer, 10, NULL, NULL, &bufferHandle2 );
             if(bufferHandle2 != DRV_SPI_BUFFER_HANDLE_INVALID )
             {
                 state++;
             }
           break;
          case 1:
           if(DRV_SPI_BufferStatus(bufferHandle2) == DRV_SPI_BUFFER_EVENT_COMPLETE)
           {
            state++;
            // All transmitter data has been sent successfully.
           }
           break;
         }
     </code>
   Remarks:
     None.
  */

 DRV_SPI_BUFFER_HANDLE
   DRV_SPI_BufferAddRead2 (
   DRV_HANDLE handle ,
   void * rxBuffer ,
   size_t size ,
   DRV_SPI_BUFFER_EVENT_HANDLER completeCB ,
   void * context ,
   DRV_SPI_BUFFER_HANDLE * jobHandle ) ;
 //*******************************************************************************
 /* Function:
         DRV_SPI_BUFFER_HANDLE DRV_SPI_BufferAddWrite2 ( DRV_HANDLE handle, void *txBuffer,
                                        size_t size, DRV_SPI_BUFFER_EVENT_HANDLER completeCB,
                                               void * context, DRV_SPI_BUFFER_HANDLE * jobHandle )
   Summary:
     Registers a buffer for a write operation. Actual transfer will happen
     in the Task function.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     Registers a buffer for a write operation. Actual transfer will happen
     in the Task function. The status of this operation can be monitored
     using DRV_SPI_BufferStatus function. A optional callback can also be
     provided that will be called when the operation is complete.
   Precondition:
     The DRV_SPI_Initialize routine must have been called for the specified
     SPI driver instance.
     DRV_SPI_Open must have been called to obtain a valid opened device
     handle.
     DRV_IO_INTENT_WRITE or DRV_IO_INTENT_READWRITE must have been specified
     in the DRV_SPI_Open call.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                 open routine
     txBuffer - The buffer which hold the data.
     size - Number of bytes to be written to the SPI bus.
     completeCB - Pointer to a function to be called when this queued operation is complete
     context - unused by the driver but this is passed to the callback when it is called
     jobHandle - pointer to the buffer handle, this will be set before the function returns and can be used in the ISR callback.
   Returns:
     If the buffer add request is successful, a valid buffer handle is returned.
     If request is not queued up, DRV_SPI_BUFFER_HANDLE_INVALID is returned.
   Example:
     <code>
     DRV_HANDLE handle; // Returned from DRV_SPI_Open
         char myBuffer[MY_BUFFER_SIZE], state = 0;
         DRV_SPI_BUFFER_HANDLE bufferHandle, bufferHandle2;
         switch ( state )
         {
          case 0:
           bufferHandle = DRV_SPI_BufferAddWrite2( handle, myBuffer, 10, NULL, NULL, &bufferHandle2 );
             if(bufferHandle2 != DRV_SPI_BUFFER_HANDLE_INVALID )
             {
                 state++;
             }
           break;
          case 1:
           if(DRV_SPI_BufferStatus(bufferHandle2) == DRV_SPI_BUFFER_EVENT_COMPLETE)
           {
            state++;
            // All transmitter data has been sent successfully.
           }
           break;
         }
     </code>
   Remarks:
     None.
 */

 DRV_SPI_BUFFER_HANDLE
   DRV_SPI_BufferAddWrite2 (
   DRV_HANDLE handle ,
   void * txBuffer ,
   size_t size ,
   DRV_SPI_BUFFER_EVENT_HANDLER completeCB ,
   void * context ,
   DRV_SPI_BUFFER_HANDLE * jobHandle ) ;
 //*******************************************************************************
 /* Function:
        DRV_SPI_BUFFER_HANDLE DRV_SPI_BufferAddWriteRead2( DRV_HANDLE handle,
             void *txBuffer, void *rxBuffer, size_t size,
                                                    DRV_SPI_BUFFER_EVENT_HANDLER completeCB,
                                                    void * context, DRV_SPI_BUFFER_HANDLE * jobHandle )
   Summary:
     Registers a buffer for a read and write operation. Actual transfer will
     happen in the Task function.
         <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     Registers a buffer for a read and write operation. Actual transfer will
     happen in the Task function. The status of this operation can be
     monitored using DRV_SPI_BufferStatus function. A optional callback can also be
     provided that will be called when the operation is complete.
   Precondition:
     The DRV_SPI_Initialize routine must have been called for the specified
     SPI driver instance.
     DRV_SPI_Open must have been called to obtain a valid opened device
     handle.
   Parameters:
     handle - A valid open-instance handle, returned from the driver's
                 open routine
     txBuffer - The buffer which hold the data.
     txSize - Number of bytes to be written to the SPI bus.
     rxBuffer - The buffer to which the data should be written to.
     rxSize - Number of bytes to be read from the SPI bus
     completeCB - Pointer to a function to be called when this queued operation is complete
     context - unused by the driver but this is passed to the callback when it is called
     jobHandle - pointer to the buffer handle, this will be set before the function returns and can be used in the ISR callback.
    Returns:
     If the buffer add request is successful, a valid buffer handle is returned.
     If request is not queued up, DRV_SPI_BUFFER_HANDLE_INVALID is returned.
   Example:
         <code>
         DRV_HANDLE handle; // Returned from DRV_SPI_Open
         char myReadBuffer[MY_BUFFER_SIZE], myWriteBuffer[MY_BUFFER_SIZE], state = 0;
         DRV_SPI_BUFFER_HANDLE bufferHandle, bufferHandle2;
         switch ( state )
         {
          case 0:
           bufferHandle = DRV_SPI_BufferAddWriteRead2( handle, myWriteBuffer, 10, myReadBuffer, 10, NULL, NULL, &bufferHandle2 );
             if(bufferHandle2 != DRV_SPI_BUFFER_HANDLE_INVALID )
             {
                 state++;
             }
           break;
          case 1:
           if(DRV_SPI_BufferStatus(bufferHandle2) == DRV_SPI_BUFFER_EVENT_COMPLETE)
           {
            state++;
            // All transmitter data has been sent successfully.
           }
           break;
         }
         </code>
   Remarks:
     None.
 */

 DRV_SPI_BUFFER_HANDLE
   DRV_SPI_BufferAddWriteRead2 (
   DRV_HANDLE handle ,
   void * txBuffer ,
   size_t txSize ,
   void * rxBuffer ,
   size_t rxSize ,
   DRV_SPI_BUFFER_EVENT_HANDLER completeCB ,
   void * context ,
   DRV_SPI_BUFFER_HANDLE * jobHandle ) ;
 // *****************************************************************************
 /* Function:
     DRV_SPI_BUFFER_EVENT DRV_SPI_BufferStatus ( DRV_SPI_BUFFER_HANDLE bufferHandle )
   Summary:
     Returns the transmitter and receiver transfer status.
     <p><b>Implementation:</b> Static/Dynamic</p>
   Description:
     This returns the transmitter and receiver transfer status.
   Precondition:
     The DRV_SPI_Initialize routine must have been called for the specified
     SPI driver instance.
     DRV_SPI_Open must have been called to obtain a valid opened device handle.
     DRV_SPI_BufferAdd<Transfer> must have been called to obtain
     the buffer handle associated with that transfer.
   Parameters:
     bufferHandle - A valid buffer handle, returned from the driver's
                       data transfer routine
   Returns:
     A DRV_SPI_BUFFER_STATUS value describing the current status of the
     transfer.
   Example:
     <code>
     // Buffer handle returned from the data transfer function
     DRV_SPI_BUFFER_HANDLE bufferHandle;
     if(DRV_SPI_BufferStatus(bufferHandle) == DRV_SPI_BUFFER_EVENT_COMPLETE)
     {
         // All transmitter data has been sent.
     }
     </code>
   Remarks:
     The returned status may contain a value with more than one of the bits
     specified in the DRV_SPI_BUFFER_STATUS enumeration set. The caller
     should perform an AND with the bit of interest and verify if the
     result is non-zero (as shown in the example) to verify the desired status
     bit.
 */

 DRV_SPI_BUFFER_EVENT
   DRV_SPI_BufferStatus (
   DRV_SPI_BUFFER_HANDLE bufferHandle ) ;
 // *****************************************************************************
 /* Function:
     bool DRV_SPIn_ReceiverBufferIsFull(void)
   Summary:
     Returns the receive buffer status. 'n' represents the instance of the
         SPI driver used.
         <p><b>Implementation:</b> Static</p>
   Description:
     This function returns the receive buffer status (full/empty).
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     Receive Buffer Status
     - 1 - Full
     - 0 - Empty
   Example:
     <code>
     bool rxBufStat;
     // Using instance 1 of SPI driver, that is n = 1
     rxBufStat = DRV_SPI1_ReceiverBufferIsFull();
         if (rxBufStat)
         {
         ...
         }
     </code>
   Remarks:
     None.
 */

 bool
   DRV_SPIn_ReceiverBufferIsFull ( void ) ;
 // *****************************************************************************
 /* Function:
     bool DRV_SPIn_TransmitterBufferIsFull(void)
   Summary:
     Returns the transmit buffer status. 'n' represents the instance of the
         SPI driver used.
         <p><b>Implementation:</b> Static</p>
   Description:
     This function returns the transmit buffer status (full/empty).
   Precondition:
     None.
   Parameters:
     None.
   Returns:
     Transmit Buffer Status
     - 1 - Full
     - 0 - Empty
   Example:
     <code>
     bool txBufStat;
     // Using instance 1 of SPI driver, that is n = 1
     txBufStat = DRV_SPI1_TransmitterBufferIsFull();
         if (txBufStat)
         {
         ...
         }
     </code>
   Remarks:
     None.
 */

 bool
   DRV_SPIn_TransmitterBufferIsFull ( void ) ;
 //DOM-IGNORE-BEGIN
 //DOM-IGNORE-END
        // #ifndef _DRV_SPI_H
 /*******************************************************************************
  End of File
 */

 #endif /*00 C:\microchip\harmony\v2_06\framework\driver\spi\drv_spi.h*/
 /*   CLOSE_FILE Include File */

 #include "driver/usb/usbhs/drv_usbhs.h"
 /* LDRA REMOVE #include "usb/usb_device.h" */
 /* OPEN FILE C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\app.h */
 /**************************************************************************************/
 /* LDRA_INSPECTED 110 S
 */
 /**************************************************************************************/
 #ifndef APP_H                                                                           /* Guard against multiple inclusion.*/
 #define APP_H
 /**************************************************************************************/
 /* ************************************************************************************/
 /* Section: Included Files */
 /**************************************************************************************/
 /**************************************************************************************/
 #include <stdint.h>
 /**************************************************************************************/
 /**************************************************************************************/
 /* Section: Data Types */
 /**************************************************************************************/
 /**************************************************************************************/
 /**************************************************************************************/
 /* APP_DATA
   Summary:
     Holds APP_DATA used for the APP tasks.
   Description:
     Holds APP_DATA used for the APP tasks. The variables
     used are stored here.
   Remarks:
     None
  */

 typedef
   struct
   {
     uint8_t RevNumber ;
   } APP_DATA ;

 extern APP_DATA
   APP ;
 /**************************************************************************************/
 /**************************************************************************************/
 /* Section: Application Initialization and State Machine Functions */
 /**************************************************************************************/
 /**************************************************************************************/
 /*!*************************************************************************************
   Function:
     void APP_Initialize(void)
   Summary:
      Autonomous tool application initialization routine.
   Description:
     This function initializes the application. It places the
     application in its initial state and prepares it to run so that its
     APP_Tasks function can be called.
   Precondition:
     All other system initialization routines should be called before calling
     this routine (in "SYS_Initialize").
   Parameters:
     None.
   Returns:
     None.
   Example:
     APP_Initialize()
   Remarks:
     This routine must be called from the main function.
 */

 void
   APP_Initialize ( void ) ;
 /*!*************************************************************************************
   Function:
     void APP_Tasks(void)
   Summary:
     Application tasks function
   Description:
     This function is the main application's tasks function. It contains the various
     tasks that are maintained during the operation of the shooting panel.
   Precondition:
     The system ("SYS_Initialize") and application ("APP_Initialize") initialization
     should be called before calling this.
   Parameters:
     None.
   Returns:
     None.
   Example:
     APP_Tasks()
   Remarks:
     This routine must be called from the main() routine.
  */

 void
   APP_Tasks ( void ) ;
        /* APP_H */
 /***************************************************************************************
  End of File
  */

 #endif /*00 C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\app.h*/
 /*   CLOSE_FILE Include File */

 // DOM-IGNORE-BEGIN
 // DOM-IGNORE-END
 // *****************************************************************************
 // *****************************************************************************
 // Section: Type Definitions
 // *****************************************************************************
 // *****************************************************************************
 // *****************************************************************************
 /* System Objects
   Summary:
     Structure holding the system's object handles
   Description:
     This structure contains the object handles for all objects in the
     MPLAB Harmony project's system configuration.
   Remarks:
     These handles are returned from the "Initialize" functions for each module
     and must be passed into the "Tasks" function for each module.
 */

 typedef
   struct
   {
     SYS_MODULE_OBJ sysTmr ;
     SYS_MODULE_OBJ drvTmr0 ;
     SYS_MODULE_OBJ drvTmr1 ;
     SYS_MODULE_OBJ drvTmr2 ;
     SYS_MODULE_OBJ drvTmr3 ;
     SYS_MODULE_OBJ drvTmr4 ;
     SYS_MODULE_OBJ drvUsart0 ;
     SYS_MODULE_OBJ drvPMP0 ;
     /*** SPI Object for Index 0 ***/
     SYS_MODULE_OBJ spiObjectIdx0 ;
     /*** SPI Object for Index 1 ***/
     SYS_MODULE_OBJ spiObjectIdx1 ;
     /*** SPI Object for Index 2 ***/
     SYS_MODULE_OBJ spiObjectIdx2 ;
     SYS_MODULE_OBJ drvUSBObject ;
     SYS_MODULE_OBJ usbDevObject0 ;
   } SYSTEM_OBJECTS ;
 // *****************************************************************************
 // *****************************************************************************
 // Section: extern declarations
 // *****************************************************************************
 // *****************************************************************************

 extern SYSTEM_OBJECTS
   sysObj ;
 //DOM-IGNORE-BEGIN
 //DOM-IGNORE-END
        /* _SYS_DEFINITIONS_H */
 /*******************************************************************************
  End of File
 */

 #endif /*00 C:\microchip\harmony\v2_06\apps\Panel_Interface_Board\firmware\src\system_config\default\system_definitions.h*/
 /*   CLOSE_FILE Include File */

 /* LDRA_HEADER_END
 :
 This
 resets
 the
 header
 comment
 count.
 */
 /**************************************************************************************/
 /**************************************************************************************/
 /* Section: Structure Data and Local Variables */
 /**************************************************************************************/
 /**************************************************************************************/
 /* ADC Data
  Summary:
  These structures hold the required states and variables to perform the ADC tasks.
  Description:
  These structures hold the required states and variables to perform the ADC tasks.
  These are here to link these structures for use by the local functions.

  Remarks:
  These are defined in adc.h
 */

 ADC_DATA
   ADC ;

 static ADC_STATES
   A_STATES ;
 /**************************************************************************************/
 /**************************************************************************************/
 /* Section: State Machine Functions */
 /**************************************************************************************/
 /**************************************************************************************/
 /***************************************************************************************
  Function:
  void ADC_Tasks ( void )
  Summary:
  This routine is the ADC_tasks function. It defines the (ADC) state machine and
  core logic.
  Remarks:
  Refer to the adc.h interface header for function usage details.
  */

 void
   ADC_Tasks ( void )    /* ADC state machine.*/
   {
  int izzqqzz=((int)(bitmapstruct.element1 |= (1 << 28))); /* 37 */
     switch (
   ( ( int )(  /* 29 */
       ADC.state
   ))*
  ((bitmapstruct.element1 |= (((  1== 1)||(qqqzzglobflag == 1)) ?  ( qqqzzglobflag ^= 1, 1 <<  29) : 0)), 1 ) /* 19 */
       )                  /* Check the machines current state.*/
       {
       case ADC_STATE_INIT :
  ((bitmapstruct.element1 |= (((  0== 1)||(qqqzzglobflag == 1)) ?  ( qqqzzglobflag ^= 1, 1 <<  30) : 0)), 1 ); /* 41 */
                               /* This machines initial state.*/
         {
           ( void ) DRV_TMR4_Start () ;/* Start the trigger timer 4 instance (using timer 3)for the ADC. Set for 1mS.*/
           DRV_ADC0_Open () ; /* Open two channels for the ADC.*/
           DRV_ADC1_Open () ; /* ADC1 will be used to scan channels.*/
           ADC.state = ADC_STATE_IDLE ;  /* Move on to idle for the ADC interrupt to show readings are available.*/
         }
   ((int)(bitmapstruct.element1 |= (1 << 31))); /* 16 */
  goto l127539 ;
       case ADC_STATE_WAIT :
  ((bitmapstruct.element2 |= (((  0== 1)||(qqqzzglobflag == 1)) ?  ( qqqzzglobflag ^= 1, 1 <<   0) : 0)), 1 ); /* 41 */
                              /* Wait for the ADC operation to complete.*/
         {
           if
             (
             ( ADC.ADCInt == true )
             )                         /* The ADC interrupt routine sets this flag when the conversion is complete.*/
  {
   ((int)(bitmapstruct.element2 |= (1 <<  1))); /* 1 */
             {
               ADC.ADCInt = false ;  /* Reset the flag.*/
               ADC.state = ADC_STATE_WAIT_FOR_TIMER ;  /* Wait for the next timer tick.*/
             }
   } else ((int)(bitmapstruct.element2 |= (1 <<  2))); /* 4 */
         }
   ((int)(bitmapstruct.element2 |= (1 <<  3))); /* 16 */
  goto l127539 ;
       case ADC_STATE_WAIT_FOR_TIMER :
  ((bitmapstruct.element2 |= (((  0== 1)||(qqqzzglobflag == 1)) ?  ( qqqzzglobflag ^= 1, 1 <<   4) : 0)), 1 ); /* 41 */
                                        /* Wait for the next timer pulse to check for ADC results.*/
         {
           if
             (
             ADC.tick == true
             )                     /* Indicates the timer has completed. Start another ADC capture.*/
  {
   ((int)(bitmapstruct.element2 |= (1 <<  5))); /* 1 */
             {
               ADC.tick = false ;  /* Reset flag.*/
               ADC.state = ADC_STATE_WAIT ;  /* Switch task to wait for another ADC capture.*/
             }
   } else ((int)(bitmapstruct.element2 |= (1 <<  6))); /* 4 */
         }
   ((int)(bitmapstruct.element2 |= (1 <<  7))); /* 16 */
  goto l127539 ;
       case ADC_STATE_IDLE :
  ((bitmapstruct.element2 |= (((  0== 1)||(qqqzzglobflag == 1)) ?  ( qqqzzglobflag ^= 1, 1 <<   8) : 0)), 1 ); /* 41 */
         {
         }
   ((int)(bitmapstruct.element2 |= (1 <<  9))); /* 16 */
  goto l127539 ;
       default :
  ((bitmapstruct.element2 |= (((  0== 1)||(qqqzzglobflag == 1)) ?  ( qqqzzglobflag ^= 1, 1 <<  10) : 0)), 1 ); /* 41 */
                  /* The default state should never be executed. */
         {
             /* Comment.*/
         }
   ((int)(bitmapstruct.element2 |= (1 << 11))); /* 16 */
  goto l127539 ;
       }
 l127539 :
  ; /* 18 */
   ((int)(bitmapstruct.element2 |= (1 << 12))); /* 30 */
     adc_63zqendz                                                                                         (      77 ) ; /* 30 */
   }
 /***************************************************************************************
  End of File
  */
 #define qqqbranches     77
 #define QQQMAXMCDCSIZE      2
 /********************** LDRA_PORT INSTRUMENTATION **********************/

 /******************* END OF LDRA_PORT INSTRUMENTATION ******************/
 #define ldra_sscanf
   /* put in undefs to protect our parameter names from macros */
 #undef f
 #undef i
 #undef j
 #undef k
 #undef s
 #undef l
 #undef ii
 #undef some
 #undef none
 #undef from
 #undef a
 #undef b
 #undef iz
 #undef jz
 #undef qqnull_params
 #define qqnull_params void
   /* Conventional Instrumentation */
 #define qqzzidfield 1
     /* single file or fileid */
     /* these have an extra field for the fileid */
     static char qqqqone[]   = "%6d\n";           /* single point */
   /* uncompressed data structures */
   /* uncompressed  bitmap */
 #define QQQFIXEDSIZE
   static int qqqlast = 0;
   extern int qqupload_registered;
   extern int adc_63zqqzqz(qqnull_params);
   extern int adc_63zqqzqz1(qqnull_params);
     /* ----------------------------------------------------------------------* 200 *
      *            Procedures
      * -----------------------------------------------------------------------------
      */
   /* ----------- zscanf ---------------------------------------------------* 201 *
    *        Returns an integer extracted from a string
    * -----------------------------------------------------------------------------
    */
   static int adc_63zscanf(char * qqscan_str)
   {
     int qqvalue;
     int qqisign;
     char * qqcptr;
     qqvalue = 0;
     qqisign = 1;
     qqcptr  = qqscan_str;
     /* Skip spaces */
     while (qqcptr[0] == ' ')
     {
       qqcptr++;
     }
     /* Check for a leading ---
     */
     if (qqcptr[0] == '-')
     {
       qqisign = -1;
       qqcptr++;
     }
     /* Extract digits */
     while ((qqcptr[0] >= '0') && (qqcptr[0] <= '9'))
     {
       qqvalue = 10 * qqvalue;
       qqvalue = qqvalue + (qqcptr[0] - '0');
       qqcptr++;
     }
     qqvalue = qqisign * qqvalue;
     return qqvalue;
   } /* end of zscanf */
   /* ----------------------------------------------------------------------* 210 *
    *    C System utilities in use:
    *        fprintf
    *        fclose
    *        sscanf
    * -----------------------------------------------------------------------------
    */
   /* ----------------------------------------------------------------------* 213 *
    *            qqoutput* suite
    *      Main output routines. These may require modification.
    * -----------------------------------------------------------------------------
    */
   /* ----------------------------------------------------------------------* 214 *
    *            qqoutput
    *    This is the principle output routine.
    * -----------------------------------------------------------------------------
    */
     static void qqoutput(FILEPOINT char * s,int i)
   /* f - file pointer, s - format string, i - integer for probe value */
   {
     /* printing to a file */
     /* fprintf exists, not threaded */
     /* fprintf exists, not threaded, ( SINGLEFILE or FILEID ) */
     ldra_sprintf2 (&ldra_buffer[0], s,i,zzfileid);
     ldra_port_write (&ldra_buffer[0]);
   } /* end of qqoutput */
     /* ----------------------------------------------------------------------* 215 *
      *            qqoutput0
      * -----------------------------------------------------------------------------
      */
     static void qqoutput0(FILEPOINT char * s)
     {
       ldra_port_write(s);
     } /* end of qqoutput0 */
   /* ----------------------------------------------------------------------* 216 *
    *            qqoutput2
    * -----------------------------------------------------------------------------
    */
     static void qqoutput2(FILEPOINT char * s,int i, int j)
   {
     ldra_sprintf2 (&ldra_buffer[0], s, i, j);
     ldra_port_write (&ldra_buffer[0]);
   } /* end of qqoutput2 */
   /* ----------------------------------------------------------------------* 217 *
    *            qqoutput3
    * -----------------------------------------------------------------------------
    */
     static void qqoutput3(FILEPOINT char * s,int i,int j,int k)
   {
     ldra_sprintf3 (&ldra_buffer[0], s, i, j, k);
     ldra_port_write (&ldra_buffer[0]);
   } /* end of qqoutput3 */
   /* ----------------------------------------------------------------------* 218 *
    *            qqoutput4
    * -----------------------------------------------------------------------------
    */
   static void qqoutput4(FILEPOINT char * s,int i,int j,int k,int l)
   {
     ldra_sprintf4 (&ldra_buffer[0], s, i, j, k, l);
     ldra_port_write (&ldra_buffer[0]);
   } /* end of qqoutput4 */
   /* ----------------------------------------------------------------------* 219 *
    *            end of qqoutput* suite
    * -----------------------------------------------------------------------------
    */
   /* ----------------------------------------------------------------------* 222 *
    *            qqqqinitialise
    * This procedure initialises the structures for
    * compressed execution histories.
    * -----------------------------------------------------------------------------
    */
   static void qqqqinitialise(int ii)
   {
     unsigned int i;
     /* First time through. */
     /* bitmap */
     /* bitmap separate */
     qqqlast = 1; /* stops qqfun() calling initialise again */
     /* bitmap */
     /* bitmap singlefile */
     /* struct singlefile notmainfl */
   } /* end of qqqqinitialise */
 /* ----------------------------------------------------------------------* 225 *
 *            qqqbitmapreset
 * This procedure resets the structures for
 * compressed execution histories.
 * -----------------------------------------------------------------------------
 */
 static void qqqbitmapreset()
 {
 struct bitmapstruct_t localbitmap = {0};
 bitmapstruct = localbitmap;
 }  /* end of qqqbitmapreset */
 #undef QQQTEMP1
 #define QQQTEMP1
   /* ----------- zqqzqz ---------------------------------------------------* 310 *
    * -----------------------------------------------------------------------------
    */
   /* ----------------------------------------------------------------------* 312 *
    * This routine opens the execution history file. It is instrumented at the
    * start of the main program if one exists in the file. In general this is
    * superceded by adc_63zqqzqz1 below.
    * -----------------------------------------------------------------------------
    */
   static int adc_63zqqzqz(qqnull_params)
   {
     if ( adc_63zzopen != 1 )
     {
 #undef QQQMUSTOPEN
       adc_63zzopen = 1;
     }
     return(1);
   }  /* end of zqqzqz */
   /* ----------- zqqzqz1 --------------------------------------------------* 315 *
    * -----------------------------------------------------------------------------
    */
   /* ----------------------------------------------------------------------* 317 *
    * This routine also opens the execution history file.  It is called
    * automatically if a probe fires and the execution history is not already
    * opened (adc_63zzopen = 0 ).
    * Because this always works ( it was intended for files with no main program
    * it is now the de facto common way to open the execution history.
    * -----------------------------------------------------------------------------
    */
   static int adc_63zqqzqz1(qqnull_params)
   {
     if ( adc_63zzopen != 1 )
     {
       ldra_port_open();  /* 7 */
       qqqqinitialise(0);
       adc_63zzopen = 1;
     }
     return(1);
   }  /* end of zqqzqz1 */
   /* ----------- zqendz ---------------------------------------------------* 330 *
    * This routine is called on exiting a routine in a
    * module. It closes the execution history.
    * -----------------------------------------------------------------------------
    */
 static int adc_63zqendz(int qqqi)
   {
     if (!qqqstructzzopen)
       {
         qqpopulate_array_fcn_ptrQQ (QQQfcn_ptr_num, qqqupload, qqqbitmapreset);
         qqqstructzzopen = 1;
       }
       if ( adc_63zzopen != 1 )
       {
         adc_63zqqzqz1();
       }
       /* ----------------------------------------------------------------------* 331 *
        * this is the one which puts an integer into
        * the execution history file and returns unity.
        * The format of each field consists of six columns,
        * the number is right justified in this field.
        * -----------------------------------------------------------------------------
        */
       if ( adc_63zzopen )
       {
         /* uncompressed */
         /* uncompressed unbuffered */
       /* uncompressed unbuffered bitmap  */
         if ( qqqi > 0 )
         {
         }
         else
         {
         }
       }
     qqqlast = 0;
     return(1);
   } /* end of zqendz */
   /* ----------------------------------------------------------------------* 335 *
    *            Output structure - qqbmsoutput
    * -----------------------------------------------------------------------------
    */
   static void qqbmsoutput(FILEPOINT char * s, unsigned int i)
     {
     static int branches_printed = 0;
     int b, last = 0;
     for(b=0;b<qqqqbmselwidth/8;b++)
       {
       ldra_sprintf1 (&ldra_buffer[0], s, (i >> last) & ~(~0 << 8));
       ldra_port_write (&ldra_buffer[0]);
       ldra_sprintf1 (&ldra_buffer[0], "%8d\n", zzfileid );
       ldra_port_write (&ldra_buffer[0]);
       last += 8;
       branches_printed += 8;
       if (branches_printed >= qqqbranches)
         {
          /* do not print any more, can be left over when using more than 8 bits to store bitmap */
          break;
         }
       }
     }
  /* ----------------------------------------------------------------------* 336 *
   *            qqqupload
   * This routine loops through the stored bitmap and
   * outputs it. It then uploads the stored mcdc.
   * -----------------------------------------------------------------------------
   */
   static void qqqupload(qqnull_params)
   {
     int i;
     /* uncompressed  bitmap (!singlefile or mainfl) separate */
     {
       adc_63zqqzqz1();
 #define ELEMENT(N) qqbmsoutput("%8d", bitmapstruct.element##N);
 #define LASTELEMENT
 #include "adc_63zbelem.def"
 #undef LASTELEMENT
 #undef ELEMENT
     }
      /* bitmap separate */
     qqqlast = 1; /* stops qqfun() calling initialise again */
   } /* end of qqqupload */
   /* ----------- zqzqzq ---------------------------------------------------* 342 *
    * -----------------------------------------------------------------------------
    */
   /* ----------------------------------------------------------------------* 344 *
    * This routine should be called before the program
    * terminates. It closes the execution history
    * -----------------------------------------------------------------------------
    */
   static int adc_63zqzqzq(int qqqi)
   {
       if ( adc_63zzopen != 1 )
       {
         adc_63zqqzqz1();
       }
       /* not compressed */
       /* do nothing for bitmap*/
       /* upload the history */
       /* bitmap */
       /* uncompressed  bitmap */
       adc_63zqendz(qqqi);
         /* qqqupload closes the execution history file */
     return(1);
   } /* end of zqzqzq */
   /*   the following routines should be left alone */
 /* END OF TESTBED INSTRUMENTATION */

DRV_TMR3_PrescalerGet
TMR_PRESCALE DRV_TMR3_PrescalerGet(void)

DRV_USART_BAUD_SET_ERROR
Definition: inszt_adc.c:15270

DRV_SPI_CLOCK_MODE_IDLE_HIGH_EDGE_RISE
Definition: inszt_adc.c:26330

PLIB_SPI_ReceiverFIFOIsEmpty
bool PLIB_SPI_ReceiverFIFOIsEmpty(SPI_MODULE_ID index)

PLIB_DMA_ExistsChannelXDisabled
bool PLIB_DMA_ExistsChannelXDisabled(DMA_MODULE_ID index)

DRV_USART_TasksError
void DRV_USART_TasksError(SYS_MODULE_OBJ object)

PLIB_USART_TransmitterAddressGet
void * PLIB_USART_TransmitterAddressGet(USART_MODULE_ID index)

PLIB_DMA_ChannelBitsGet
uint8_t PLIB_DMA_ChannelBitsGet(DMA_MODULE_ID index)

DRV_IO_BUFFER_TYPES
DRV_IO_BUFFER_TYPES
Definition: inszt_adc.c:1076

DRV_USART_INIT_FLAG_STOP_IN_IDLE
Definition: inszt_adc.c:15389

SYS_PORTS_PULLUP_ENABLE
Definition: inszt_adc.c:21873

PLIB_USART_TransmitterEnable
void PLIB_USART_TransmitterEnable(USART_MODULE_ID index)

PLIB_PORTS_ExistsChangeNoticeEdgeStatus
bool PLIB_PORTS_ExistsChangeNoticeEdgeStatus(PORTS_MODULE_ID index)

SYS_DMA_Suspend
void SYS_DMA_Suspend(void)

DRV_USART_ReceiverBufferIsEmpty
bool DRV_USART_ReceiverBufferIsEmpty(const DRV_HANDLE handle)

PLIB_PORTS_ChangeNoticeInIdlePerPortDisable
void PLIB_PORTS_ChangeNoticeInIdlePerPortDisable(PORTS_MODULE_ID index, PORTS_CHANNEL channel)

_DRV_SPI_INIT::baudClockSource
SPI_BAUD_RATE_CLOCK baudClockSource
Definition: inszt_adc.c:26566

DRV_ADC_Initialize
void DRV_ADC_Initialize(void)

DRV_CLIENT_STATUS_READY
Definition: inszt_adc.c:1032

DRV_USART0_TransferStatus
DRV_USART_TRANSFER_STATUS DRV_USART0_TransferStatus(void)

DRV_SPI_BufferAddWrite2
DRV_SPI_BUFFER_HANDLE DRV_SPI_BufferAddWrite2(DRV_HANDLE handle, void *txBuffer, size_t size, DRV_SPI_BUFFER_EVENT_HANDLER completeCB, void *context, DRV_SPI_BUFFER_HANDLE *jobHandle)

PLIB_PORTS_ExistsPortsDirection
bool PLIB_PORTS_ExistsPortsDirection(PORTS_MODULE_ID index)

DRV_TMR4_PeriodValueGet
uint32_t DRV_TMR4_PeriodValueGet(void)

SYS_DMA_TRANSFER_EVENT_ABORT
Definition: inszt_adc.c:13477

DRV_USART_BufferProcessedSizeGet
size_t DRV_USART_BufferProcessedSizeGet(DRV_USART_BUFFER_HANDLE bufferHandle)

qqoutput0
static void qqoutput0(FILEPOINT char *s)
Definition: inszt_adc.c:27923

PLIB_USART_ExistsReceiverIdleStateLowEnable
bool PLIB_USART_ExistsReceiverIdleStateLowEnable(USART_MODULE_ID index)

PLIB_DMA_CRCWriteByteOrderAlter
void PLIB_DMA_CRCWriteByteOrderAlter(DMA_MODULE_ID index)

DRV_USART0_ErrorGet
DRV_USART_ERROR DRV_USART0_ErrorGet(void)

PLIB_DMA_ExistsCRCBitOrder
bool PLIB_DMA_ExistsCRCBitOrder(DMA_MODULE_ID index)

ADC_STATES
ADC_STATES
Definition: inszt_adc.c:231

qqoutput3
static void qqoutput3(FILEPOINT char *s, int i, int j, int k)
Definition: inszt_adc.c:27940

APP
APP_DATA APP
Definition: app.c:73

PLIB_DMA_ExistsChannelXTrigger
bool PLIB_DMA_ExistsChannelXTrigger(DMA_MODULE_ID index)

PLIB_DMA_IsBusy
bool PLIB_DMA_IsBusy(DMA_MODULE_ID index)

PLIB_DMA_ExistsChannelXDestinationSize
bool PLIB_DMA_ExistsChannelXDestinationSize(DMA_MODULE_ID index)

PLIB_DMA_ExistsChannelXEvent
bool PLIB_DMA_ExistsChannelXEvent(DMA_MODULE_ID index)

PLIB_DMA_ExistsLastBusAccess
bool PLIB_DMA_ExistsLastBusAccess(DMA_MODULE_ID index)

PLIB_PORTS_PinOpenDrainDisable
void PLIB_PORTS_PinOpenDrainDisable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

SYS_DMA_TRANSFER_EVENT_NONE
Definition: inszt_adc.c:13479

ADC_DATA::state
ADC_STATES state
Definition: adc.h:81

DRV_TMR_INIT::interruptSource
INT_SOURCE interruptSource
Definition: inszt_adc.c:1906

SYS_DEBUG_Status
SYS_STATUS SYS_DEBUG_Status(SYS_MODULE_OBJ object)

PLIB_SPI_ExistsErrorInterruptControl
bool PLIB_SPI_ExistsErrorInterruptControl(SPI_MODULE_ID index)

DRV_USART_BUFFER_EVENT_HANDLER
void(* DRV_USART_BUFFER_EVENT_HANDLER)(DRV_USART_BUFFER_EVENT event, DRV_USART_BUFFER_HANDLE bufferHandle, uintptr_t context)
Definition: inszt_adc.c:15196

PLIB_SPI_ExistsEnableControl
bool PLIB_SPI_ExistsEnableControl(SPI_MODULE_ID index)

SYS_DMA_ChannelDisable
void SYS_DMA_ChannelDisable(SYS_DMA_CHANNEL_HANDLE handle)

DRV_PMP0_TimingSet
void DRV_PMP0_TimingSet(PMP_DATA_WAIT_STATES dataWait, PMP_STROBE_WAIT_STATES strobeWait, PMP_DATA_HOLD_STATES dataHold)

PLIB_SPI_BufferWrite
void PLIB_SPI_BufferWrite(SPI_MODULE_ID index, uint8_t data)

DRV_USART_TRANSFER_STATUS_TRANSMIT_EMPTY
Definition: inszt_adc.c:15508

PLIB_USART_ReceiverAddressDetectEnable
void PLIB_USART_ReceiverAddressDetectEnable(USART_MODULE_ID index)

DRV_TMR0_CounterValueSet
void DRV_TMR0_CounterValueSet(uint32_t value)

DRV_TMR3_ClientStatus
DRV_TMR_CLIENT_STATUS DRV_TMR3_ClientStatus(void)

SYS_DMA_CHANNEL_OPERATION_MODE_CRC::type
DMA_CRC_TYPE type
Definition: inszt_adc.c:13435

DRV_TMR4_StopInIdleEnable
void DRV_TMR4_StopInIdleEnable(void)

DRV_TMR0_Tasks
static void DRV_TMR0_Tasks(void)
Definition: inszt_adc.c:3785

DRV_USART0_Deinitialize
void DRV_USART0_Deinitialize(void)

PLIB_SPI_ExistsFIFOShiftRegisterEmptyStatus
bool PLIB_SPI_ExistsFIFOShiftRegisterEmptyStatus(SPI_MODULE_ID index)

PLIB_DMA_ExistsBusy
bool PLIB_DMA_ExistsBusy(DMA_MODULE_ID index)

SYS_PORTS_PinRead
bool SYS_PORTS_PinRead(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

PLIB_SPI_ExistsTransmitUnderRunStatus
bool PLIB_SPI_ExistsTransmitUnderRunStatus(SPI_MODULE_ID index)

PLIB_USART_WakeOnStartDisable
void PLIB_USART_WakeOnStartDisable(USART_MODULE_ID index)

PLIB_USART_ExistsLoopback
bool PLIB_USART_ExistsLoopback(USART_MODULE_ID index)

DRV_TMR4_DividerRangeGet
DRV_TMR_OPERATION_MODE DRV_TMR4_DividerRangeGet(DRV_TMR_DIVIDER_RANGE *pDivRange)

DRV_USART_BUFFER_EVENT_ERROR
Definition: inszt_adc.c:15102

DRV_USART_LINE_CONTROL_9NONE2
Definition: inszt_adc.c:15347

PLIB_DMA_ChannelXPeripheralAddressSet
void PLIB_DMA_ChannelXPeripheralAddressSet(DMA_MODULE_ID index, DMA_CHANNEL channel, uint16_t peripheraladdress)

PORTS_DATA_MASK
uint16_t PORTS_DATA_MASK
Definition: inszt_adc.c:18519

DRV_TMR2_PrescalerGet
TMR_PRESCALE DRV_TMR2_PrescalerGet(void)

PLIB_DMA_ChannelXReloadEnable
void PLIB_DMA_ChannelXReloadEnable(DMA_MODULE_ID index, DMA_CHANNEL channel)

PLIB_SPI_ExistsFrameSyncPulseWidth
bool PLIB_SPI_ExistsFrameSyncPulseWidth(SPI_MODULE_ID index)

PLIB_SPI_PinEnable
void PLIB_SPI_PinEnable(SPI_MODULE_ID index, SPI_PIN pin)

DRV_TMR_Stop
void DRV_TMR_Stop(DRV_HANDLE handle)

DRV_TMR_CounterClear
void DRV_TMR_CounterClear(DRV_HANDLE handle)

DRV_USART_OBJ::error
DRV_USART_ERROR error
Definition: inszt_adc.c:18264

PLIB_USART_RunInOverflowEnable
void PLIB_USART_RunInOverflowEnable(USART_MODULE_ID index)

PLIB_SPI_ErrorInterruptDisable
void PLIB_SPI_ErrorInterruptDisable(SPI_MODULE_ID index, SPI_ERROR_INTERRUPT error)

PLIB_PORTS_ChangeNoticePullDownPerPortDisable
void PLIB_PORTS_ChangeNoticePullDownPerPortDisable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

DRV_TMR_OPERATION_MODE_NONE
Definition: inszt_adc.c:1852

_DRV_SPI_INIT::framePulsePolarity
SPI_FRAME_PULSE_POLARITY framePulsePolarity
Definition: inszt_adc.c:26551

SYS_DMA_ChannelTransferAdd
void SYS_DMA_ChannelTransferAdd(SYS_DMA_CHANNEL_HANDLE handle, const void *srcAddr, size_t srcSize, const void *destAddr, size_t destSize, size_t cellSize)

PLIB_DMA_ExistsChannelXPatternIgnore
bool PLIB_DMA_ExistsChannelXPatternIgnore(DMA_MODULE_ID index)

PLIB_SPI_ExistsFIFOInterruptMode
bool PLIB_SPI_ExistsFIFOInterruptMode(SPI_MODULE_ID index)

DRV_USART0_Close
void DRV_USART0_Close(void)

DRV_TMR4_PeriodValueSet
void DRV_TMR4_PeriodValueSet(uint32_t value)

PLIB_USART_ReceiverIdleStateLowDisable
void PLIB_USART_ReceiverIdleStateLowDisable(USART_MODULE_ID index)

DRV_CLIENT_STATUS_ERROR_EXTENDED
Definition: inszt_adc.c:1023

SYS_DMA_SIDL_DISABLE
Definition: inszt_adc.c:13279

DRV_USART0_BaudSet
DRV_USART_BAUD_SET_RESULT DRV_USART0_BaudSet(uint32_t baud)

SYS_DEBUG_Deinitialize
void SYS_DEBUG_Deinitialize(SYS_MODULE_OBJ object)

PLIB_SPI_FrameSyncPulseEdgeSelect
void PLIB_SPI_FrameSyncPulseEdgeSelect(SPI_MODULE_ID index, SPI_FRAME_PULSE_EDGE edge)

DRV_USART_INIT::modeData
DRV_USART_OPERATION_MODE_DATA modeData
Definition: inszt_adc.c:15541

SYS_DMA_ChannelCRCGet
uint32_t SYS_DMA_ChannelCRCGet(void)

DRV_SPI_PROTOCOL_TYPE_FRAMED
Definition: inszt_adc.c:26376

PLIB_USART_WakeOnStartEnable
void PLIB_USART_WakeOnStartEnable(USART_MODULE_ID index)

DRV_TMR4_ClientStatus
DRV_TMR_CLIENT_STATUS DRV_TMR4_ClientStatus(void)

PLIB_SPI_ReadDataIsSignExtended
bool PLIB_SPI_ReadDataIsSignExtended(SPI_MODULE_ID index)

PLIB_SPI_ClockPolaritySelect
void PLIB_SPI_ClockPolaritySelect(SPI_MODULE_ID index, SPI_CLOCK_POLARITY polarity)

DRV_IC_BufferIsEmpty
bool DRV_IC_BufferIsEmpty(DRV_HANDLE handle)

PLIB_DMA_ChannelXSourcePointerGet
uint16_t PLIB_DMA_ChannelXSourcePointerGet(DMA_MODULE_ID index, DMA_CHANNEL dmaChannel)

PLIB_DMA_ChannelXPingPongModeGet
DMA_PING_PONG_MODE PLIB_DMA_ChannelXPingPongModeGet(DMA_MODULE_ID index, DMA_CHANNEL channel)

DRV_TMR1_DeInitialize
static void DRV_TMR1_DeInitialize(void)
Definition: inszt_adc.c:3814

DRV_USART_Deinitialize
void DRV_USART_Deinitialize(SYS_MODULE_OBJ object)

PLIB_USART_RunInSleepModeDisable
void PLIB_USART_RunInSleepModeDisable(USART_MODULE_ID index)

DRV_TMR0_PeriodValueSet
void DRV_TMR0_PeriodValueSet(uint32_t value)

DRV_SPI_CLOCK_MODE_IDLE_HIGH_EDGE_FALL
Definition: inszt_adc.c:26322

DRV_IC_Start
DRV_HANDLE DRV_IC_Start(const SYS_MODULE_INDEX drvIndex, const DRV_IO_INTENT intent)

PLIB_SPI_SlaveEnable
void PLIB_SPI_SlaveEnable(SPI_MODULE_ID index)

PLIB_USART_IrDAEnable
void PLIB_USART_IrDAEnable(USART_MODULE_ID index)

PLIB_DMA_SuspendDisable
void PLIB_DMA_SuspendDisable(DMA_MODULE_ID index)

qqqstructzzopen
static int qqqstructzzopen
Definition: inszt_adc.c:136

DRV_TMR_INIT::prescale
TMR_PRESCALE prescale
Definition: inszt_adc.c:1902

DRV_USART_INIT::usartID
USART_MODULE_ID usartID
Definition: inszt_adc.c:15533

DRV_SPI_PROTOCOL_TYPE
DRV_SPI_PROTOCOL_TYPE
Definition: inszt_adc.c:26367

PLIB_USART_ExistsIrDA
bool PLIB_USART_ExistsIrDA(USART_MODULE_ID index)

SYS_DMA_CHANNEL_OP_MODE_CRC
Definition: inszt_adc.c:13415

PLIB_DMA_ChannelXPatternDataGet
uint16_t PLIB_DMA_ChannelXPatternDataGet(DMA_MODULE_ID index, DMA_CHANNEL dmaChannel)

SYS_DMA_Tasks
void SYS_DMA_Tasks(SYS_MODULE_OBJ object, DMA_CHANNEL activeChannel)

PLIB_USART_BaudRateSet
void PLIB_USART_BaudRateSet(USART_MODULE_ID index, uint32_t clockFrequency, uint32_t baudRate)

DRV_USART_LINE_CONTROL_SET_RESULT
DRV_USART_LINE_CONTROL_SET_RESULT
Definition: inszt_adc.c:15287

PLIB_PORTS_CnPinsPullUpEnable
void PLIB_PORTS_CnPinsPullUpEnable(PORTS_MODULE_ID index, PORTS_CN_PIN cnPins)

PLIB_PORTS_AnPinsModeSelect
void PLIB_PORTS_AnPinsModeSelect(PORTS_MODULE_ID index, PORTS_AN_PIN anPins, PORTS_PIN_MODE mode)

PLIB_DMA_CRCByteOrderGet
DMA_CRC_BYTE_ORDER PLIB_DMA_CRCByteOrderGet(DMA_MODULE_ID index)

SYS_DMA_SIDL_ENABLE
Definition: inszt_adc.c:13281

DRV_SPI_ClientConfigure
int32_t DRV_SPI_ClientConfigure(DRV_HANDLE handle, const DRV_SPI_CLIENT_DATA *cfgData)

SYS_DMA_ChannelSuspend
void SYS_DMA_ChannelSuspend(SYS_DMA_CHANNEL_HANDLE handle)

DRV_USART0_ReadByte
uint8_t DRV_USART0_ReadByte(void)

bitmapstruct
static struct bitmapstruct_t bitmapstruct

DRV_TMR_CLKSOURCE_LPRC_OSCILLATOR_ASYNCHRONOUS
Definition: inszt_adc.c:1734

SYS_PORTS_InterruptStatusGet
PORTS_DATA_TYPE SYS_PORTS_InterruptStatusGet(PORTS_MODULE_ID index, PORTS_CHANNEL channel)

A_STATES
static ADC_STATES A_STATES
Definition: inszt_adc.c:27723

DRV_TMR1_Open
static void DRV_TMR1_Open(void)
Definition: inszt_adc.c:3834

PLIB_DMA_ChannelXPrioritySelect
void PLIB_DMA_ChannelXPrioritySelect(DMA_MODULE_ID index, DMA_CHANNEL channel, DMA_CHANNEL_PRIORITY channelPriority)

PLIB_DMA_ExistsChannelXChainEnbl
bool PLIB_DMA_ExistsChannelXChainEnbl(DMA_MODULE_ID index)

DRV_IO_BUFFER_TYPE_RW
Definition: inszt_adc.c:1086

PLIB_PORTS_ExistsChangeNoticePerPortTurnOn
bool PLIB_PORTS_ExistsChangeNoticePerPortTurnOn(PORTS_MODULE_ID index)

DRV_SPI_BufferAddRead
DRV_SPI_BUFFER_HANDLE DRV_SPI_BufferAddRead(DRV_HANDLE handle, void *rxBuffer, size_t size, DRV_SPI_BUFFER_EVENT_HANDLER completeCB, void *context)

PLIB_DMA_CRCAppendModeDisable
void PLIB_DMA_CRCAppendModeDisable(DMA_MODULE_ID index)

DRV_USART_INIT_FLAG_NONE
Definition: inszt_adc.c:15368

PLIB_DMA_ChannelXTriggerEnable
void PLIB_DMA_ChannelXTriggerEnable(DMA_MODULE_ID index, DMA_CHANNEL channel, DMA_CHANNEL_TRIGGER_TYPE trigger)

DRV_TMR3_PeriodValueGet
uint32_t DRV_TMR3_PeriodValueGet(void)

PLIB_PORTS_ChangeNoticePullUpEnable
void PLIB_PORTS_ChangeNoticePullUpEnable(PORTS_MODULE_ID index, PORTS_CHANGE_NOTICE_PIN pinNum)

PLIB_USART_WakeOnStartIsEnabled
bool PLIB_USART_WakeOnStartIsEnabled(USART_MODULE_ID index)

PLIB_PORTS_DirectionInputSet
void PLIB_PORTS_DirectionInputSet(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_DATA_MASK mask)

PLIB_PORTS_PinOpenDrainEnable
void PLIB_PORTS_PinOpenDrainEnable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

DRV_USART_LINE_CONTROL
DRV_USART_LINE_CONTROL
Definition: inszt_adc.c:15315

PLIB_DMA_ExistsStartTransfer
bool PLIB_DMA_ExistsStartTransfer(DMA_MODULE_ID index)

DRV_TMR_ClientStatus
DRV_TMR_CLIENT_STATUS DRV_TMR_ClientStatus(DRV_HANDLE handle)

PLIB_USART_ReceiverEnable
void PLIB_USART_ReceiverEnable(USART_MODULE_ID index)

DRV_SPI_INIT
struct _DRV_SPI_INIT DRV_SPI_INIT

PLIB_SPI_BufferRead
uint8_t PLIB_SPI_BufferRead(SPI_MODULE_ID index)

PORTS_PIN_INTERRUPT_NONE
Definition: inszt_adc.c:21906

DRV_SPI_BUFFER_EVENT_HANDLER
void(* DRV_SPI_BUFFER_EVENT_HANDLER)(DRV_SPI_BUFFER_EVENT event, DRV_SPI_BUFFER_HANDLE bufferHandle, void *context)
Definition: inszt_adc.c:26515

DRV_IO_INTENT_WRITE
Definition: inszt_adc.c:983

DRV_USART_BAUD_SET_RESULT
DRV_USART_BAUD_SET_RESULT
Definition: inszt_adc.c:15266

PLIB_USART_StopInIdleEnable
void PLIB_USART_StopInIdleEnable(USART_MODULE_ID index)

SYS_DMA_CHANNEL_CHAIN_PRIO_HIGH
Definition: inszt_adc.c:13299

PLIB_PORTS_ExistsPinModePerPort
bool PLIB_PORTS_ExistsPinModePerPort(PORTS_MODULE_ID index)

PLIB_DMA_SuspendEnable
void PLIB_DMA_SuspendEnable(DMA_MODULE_ID index)

DRV_TMR1_Tasks
static void DRV_TMR1_Tasks(void)
Definition: inszt_adc.c:3895

SYS_PORTS_ChangeNotificationGlobalEnable
void SYS_PORTS_ChangeNotificationGlobalEnable(PORTS_MODULE_ID index)

PLIB_USART_Receiver9BitsReceive
int16_t PLIB_USART_Receiver9BitsReceive(USART_MODULE_ID index)

PLIB_DMA_ExistsStopInIdle
bool PLIB_DMA_ExistsStopInIdle(DMA_MODULE_ID index)

PLIB_SPI_AudioProtocolDisable
void PLIB_SPI_AudioProtocolDisable(SPI_MODULE_ID index)

DRV_TMR4_StopInIdleDisable
void DRV_TMR4_StopInIdleDisable(void)

DRV_TMR0_ClientStatus
DRV_TMR_CLIENT_STATUS DRV_TMR0_ClientStatus(void)

DRV_USART_INIT::dmaInterruptReceive
INT_SOURCE dmaInterruptReceive
Definition: inszt_adc.c:15605

SYS_DEBUG_INIT::moduleInit
SYS_MODULE_INIT moduleInit
Definition: inszt_adc.c:17596

PLIB_SPI_FrameErrorStatusGet
bool PLIB_SPI_FrameErrorStatusGet(SPI_MODULE_ID index)

DRV_SPI_CLIENT_DATA
struct _DRV_SPI_CLIENT_DATA DRV_SPI_CLIENT_DATA

SYS_PORTS_Read
PORTS_DATA_TYPE SYS_PORTS_Read(PORTS_MODULE_ID index, PORTS_CHANNEL channel)

DRV_TMR0_Close
static void DRV_TMR0_Close(void)
Definition: inszt_adc.c:3745

DRV_SPI_PROTOCOL_TYPE_AUDIO
Definition: inszt_adc.c:26381

PLIB_SPI_ExistsFIFOCount
bool PLIB_SPI_ExistsFIFOCount(SPI_MODULE_ID index)

DRV_USART_BufferEventHandlerSet
void DRV_USART_BufferEventHandlerSet(const DRV_HANDLE handle, const DRV_USART_BUFFER_EVENT_HANDLER eventHandler, const uintptr_t context)

DRV_USART_CLIENT_STATUS_ERROR
Definition: inszt_adc.c:15468

SYS_DMA_ChannelDestinationTransferredSizeGet
size_t SYS_DMA_ChannelDestinationTransferredSizeGet(SYS_DMA_CHANNEL_HANDLE handle)

PLIB_SPI_ExistsStopInIdleControl
bool PLIB_SPI_ExistsStopInIdleControl(SPI_MODULE_ID index)

_DRV_SPI_INIT::jobQueueReserveSize
uint8_t jobQueueReserveSize
Definition: inszt_adc.c:26596

PLIB_SPI_ExistsTransmitBufferEmptyStatus
bool PLIB_SPI_ExistsTransmitBufferEmptyStatus(SPI_MODULE_ID index)

DRV_TMR2_DeInitialize
static void DRV_TMR2_DeInitialize(void)
Definition: inszt_adc.c:3924

PLIB_SPI_ExistsClockPolarity
bool PLIB_SPI_ExistsClockPolarity(SPI_MODULE_ID index)

PLIB_DMA_Disable
void PLIB_DMA_Disable(DMA_MODULE_ID index)

SYS_PORTS_RemapInput
void SYS_PORTS_RemapInput(PORTS_MODULE_ID index, PORTS_REMAP_INPUT_FUNCTION function, PORTS_REMAP_INPUT_PIN remapPin)

DRV_TMR_CLIENT_STATUS
DRV_TMR_CLIENT_STATUS
Definition: inszt_adc.c:1801

_DRV_SPI_CLIENT_DATA
Definition: inszt_adc.c:26624

DRV_TMR4_PrescalerGet
TMR_PRESCALE DRV_TMR4_PrescalerGet(void)

PLIB_USART_ErrorsGet
USART_ERROR PLIB_USART_ErrorsGet(USART_MODULE_ID index)

PLIB_DMA_ChannelXEnable
void PLIB_DMA_ChannelXEnable(DMA_MODULE_ID index, DMA_CHANNEL channel)

_DRV_SPI_INIT::moduleInit
SYS_MODULE_INIT moduleInit
Definition: inszt_adc.c:26535

PLIB_DMA_IsEnabled
bool PLIB_DMA_IsEnabled(DMA_MODULE_ID index)

DRV_USART0_ClientStatus
DRV_USART_CLIENT_STATUS DRV_USART0_ClientStatus(void)

DRV_TMR_AlarmEnable
void DRV_TMR_AlarmEnable(DRV_HANDLE handle, bool enable)

PLIB_DMA_ChannelXDestinationStartAddressGet
uint32_t PLIB_DMA_ChannelXDestinationStartAddressGet(DMA_MODULE_ID index, DMA_CHANNEL dmaChannel)

SYS_PORTS_PinOpenDrainDisable
void SYS_PORTS_PinOpenDrainDisable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

DRV_CLIENT_STATUS_CLOSED
Definition: inszt_adc.c:1028

DRV_USART_CLIENT_STATUS_CLOSED
Definition: inszt_adc.c:15471

SYS_PORTS_PinModeSelect
void SYS_PORTS_PinModeSelect(PORTS_MODULE_ID index, PORTS_ANALOG_PIN pin, PORTS_PIN_MODE mode)

SYS_DMA_ChannelAllocate
SYS_DMA_CHANNEL_HANDLE SYS_DMA_ChannelAllocate(DMA_CHANNEL channel)

PLIB_PORTS_ExistsChangeNoticePerPortInIdle
bool PLIB_PORTS_ExistsChangeNoticePerPortInIdle(PORTS_MODULE_ID index)

DRV_CLIENT_STATUS_BUSY
Definition: inszt_adc.c:1030

DRV_USART_Close
void DRV_USART_Close(const DRV_HANDLE handle)

DRV_TMR3_CounterFrequencyGet
uint32_t DRV_TMR3_CounterFrequencyGet(void)

PLIB_SPI_FIFOInterruptModeSelect
void PLIB_SPI_FIFOInterruptModeSelect(SPI_MODULE_ID index, SPI_FIFO_INTERRUPT mode)

PLIB_SPI_ExistsAudioProtocolControl
bool PLIB_SPI_ExistsAudioProtocolControl(SPI_MODULE_ID index)

DRV_TMR4_OperationModeGet
static DRV_TMR_OPERATION_MODE DRV_TMR4_OperationModeGet(void)
Definition: inszt_adc.c:4175

DRV_USART_INIT::interruptTransmit
INT_SOURCE interruptTransmit
Definition: inszt_adc.c:15571

DRV_IO_INTENT_NONBLOCKING
Definition: inszt_adc.c:995

PLIB_DMA_ChannelXAddressModeSelect
void PLIB_DMA_ChannelXAddressModeSelect(DMA_MODULE_ID index, DMA_CHANNEL channel, DMA_CHANNEL_ADDRESSING_MODE channelAddressMode)

PLIB_DMA_ChannelXChainEnable
void PLIB_DMA_ChannelXChainEnable(DMA_MODULE_ID index, DMA_CHANNEL channel)

PLIB_SPI_ExistsInputSamplePhase
bool PLIB_SPI_ExistsInputSamplePhase(SPI_MODULE_ID index)

PLIB_SPI_ExistsFrameSyncPulsePolarity
bool PLIB_SPI_ExistsFrameSyncPulsePolarity(SPI_MODULE_ID index)

PLIB_USART_ModuleIsBusy
bool PLIB_USART_ModuleIsBusy(USART_MODULE_ID index)

qqqisinitialised
static int qqqisinitialised
Definition: inszt_main.c:152

SYS_PORTS_PinPullUpEnable
void SYS_PORTS_PinPullUpEnable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

DRV_TMR_DIVIDER_RANGE::dividerMax
uint32_t dividerMax
Definition: inszt_adc.c:1877

PLIB_DMA_ChannelXOperatingTransferModeGet
DMA_TRANSFER_MODE PLIB_DMA_ChannelXOperatingTransferModeGet(DMA_MODULE_ID index, DMA_CHANNEL channel)

SYS_PORTS_PULLUP_DISABLE
Definition: inszt_adc.c:21868

DRV_USART_ByteReceiveCallbackSet
void DRV_USART_ByteReceiveCallbackSet(const SYS_MODULE_INDEX index, const DRV_USART_BYTE_EVENT_HANDLER eventHandler)

PLIB_DMA_CRCDataWrite
void PLIB_DMA_CRCDataWrite(DMA_MODULE_ID index, uint32_t DMACRCdata)

DRV_SPI_TASK_MODE
DRV_SPI_TASK_MODE
Definition: inszt_adc.c:26444

DRV_ADC_DeInitialize
void DRV_ADC_DeInitialize(void)

SYS_DMA_CHANNEL_OPERATION_MODE_CRC::data
uint32_t data
Definition: inszt_adc.c:13453

PLIB_DMA_ChannelXINTSourceFlagClear
void PLIB_DMA_ChannelXINTSourceFlagClear(DMA_MODULE_ID index, DMA_CHANNEL dmaChannel, DMA_INT_TYPE dmaINTSource)

DRV_ADC_SamplesAvailable
bool DRV_ADC_SamplesAvailable(uint8_t bufIndex)

PLIB_DMA_CRCTypeGet
DMA_CRC_TYPE PLIB_DMA_CRCTypeGet(DMA_MODULE_ID index)

DRV_TMR_Initialize
SYS_MODULE_OBJ DRV_TMR_Initialize(const SYS_MODULE_INDEX drvIndex, const SYS_MODULE_INIT *const init)

PLIB_DMA_ChannelXDestinationPointerGet
uint16_t PLIB_DMA_ChannelXDestinationPointerGet(DMA_MODULE_ID index, DMA_CHANNEL dmaChannel)

PLIB_SPI_ExistsAudioProtocolMode
bool PLIB_SPI_ExistsAudioProtocolMode(SPI_MODULE_ID index)

SYS_DMA_DATA_WIDTH_NONE
Definition: inszt_adc.c:13526

DRV_USART0_WriteByte
void DRV_USART0_WriteByte(const uint8_t byte)

DRV_SPI_BufferAddWriteRead
DRV_SPI_BUFFER_HANDLE DRV_SPI_BufferAddWriteRead(DRV_HANDLE handle, void *txBuffer, size_t txSize, void *rxBuffer, size_t rxSize, DRV_SPI_BUFFER_EVENT_HANDLER completeCB, void *context)

PLIB_PORTS_ChangeNoticeInIdleDisable
void PLIB_PORTS_ChangeNoticeInIdleDisable(PORTS_MODULE_ID index)

PLIB_SPI_TransmitBufferIsEmpty
bool PLIB_SPI_TransmitBufferIsEmpty(SPI_MODULE_ID index)

DRV_TMR_AlarmRegister
bool DRV_TMR_AlarmRegister(DRV_HANDLE handle, uint32_t divider, bool isPeriodic, uintptr_t context, DRV_TMR_CALLBACK callBack)

PLIB_PORTS_ChannelChangeNoticeMethodGet
PORTS_CHANGE_NOTICE_METHOD PLIB_PORTS_ChannelChangeNoticeMethodGet(PORTS_MODULE_ID index, PORTS_CHANNEL channel)

PLIB_SPI_FrameErrorStatusClear
void PLIB_SPI_FrameErrorStatusClear(SPI_MODULE_ID index)

PLIB_PORTS_ChannelChangeNoticeEnable
void PLIB_PORTS_ChannelChangeNoticeEnable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_DATA_MASK mask)

DRV_TMR_DIVIDER_RANGE::dividerStep
uint32_t dividerStep
Definition: inszt_adc.c:1880

PLIB_USART_BaudRateHighDisable
void PLIB_USART_BaudRateHighDisable(USART_MODULE_ID index)

PLIB_DMA_CRCXOREnableSet
void PLIB_DMA_CRCXOREnableSet(DMA_MODULE_ID index, uint32_t DMACRCXOREnableMask)

DRV_TMR2_Initialize
void DRV_TMR2_Initialize(void)

DRV_TMR1_CounterValueGet
uint32_t DRV_TMR1_CounterValueGet(void)

_DRV_SPI_INIT::txInterruptSource
INT_SOURCE txInterruptSource
Definition: inszt_adc.c:26580

DRV_SPI_BUFFER_TYPE
DRV_SPI_BUFFER_TYPE
Definition: inszt_adc.c:26344

PLIB_USART_ReceiverFramingErrorHasOccurred
bool PLIB_USART_ReceiverFramingErrorHasOccurred(USART_MODULE_ID index)

PLIB_DMA_ChannelXPriorityGet
DMA_CHANNEL_PRIORITY PLIB_DMA_ChannelXPriorityGet(DMA_MODULE_ID index, DMA_CHANNEL channel)

PLIB_PORTS_ExistsChangeNoticePullUp
bool PLIB_PORTS_ExistsChangeNoticePullUp(PORTS_MODULE_ID index)

PLIB_USART_ReceiverAddressAutoDetectDisable
void PLIB_USART_ReceiverAddressAutoDetectDisable(USART_MODULE_ID index)

DRV_USART_OPERATION_MODE_DATA::address
uint8_t address
Definition: inszt_adc.c:15411

PLIB_DMA_ChannelXSourceAddressModeGet
DMA_SOURCE_ADDRESSING_MODE PLIB_DMA_ChannelXSourceAddressModeGet(DMA_MODULE_ID index, DMA_CHANNEL channel)

DRV_TMR0_CounterClear
void DRV_TMR0_CounterClear(void)

DRV_USART0_TransmitBufferSizeGet
unsigned int DRV_USART0_TransmitBufferSizeGet(void)

PLIB_DMA_ExistsCRCData
bool PLIB_DMA_ExistsCRCData(DMA_MODULE_ID index)

DRV_SPI_BUFFER_EVENT_COMPLETE
Definition: inszt_adc.c:26407

DRV_USART_ERROR_RECEIVE_OVERRUN
Definition: inszt_adc.c:15445

PLIB_PORTS_PinGet
bool PLIB_PORTS_PinGet(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

SYS_DMA_CHANNEL_OP_MODE_CHAIN_HIGH
Definition: inszt_adc.c:13401

PLIB_USART_ReceiverAddressIsReceived
bool PLIB_USART_ReceiverAddressIsReceived(USART_MODULE_ID index)

SYSTEM_OBJECTS::sysTmr
SYS_MODULE_OBJ sysTmr
Definition: inszt_adc.c:27659

PLIB_SPI_FrameSyncPulseCounterSelect
void PLIB_SPI_FrameSyncPulseCounterSelect(SPI_MODULE_ID index, SPI_FRAME_SYNC_PULSE pulse)

PLIB_PORTS_ChannelModeSelect
void PLIB_PORTS_ChannelModeSelect(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_DATA_MASK modeMask, PORTS_PIN_MODE mode)

SYS_DEBUG_Tasks
void SYS_DEBUG_Tasks(SYS_MODULE_OBJ object)

PLIB_DMA_CRCDisable
void PLIB_DMA_CRCDisable(DMA_MODULE_ID index)

SYS_DMA_ERROR_NONE
Definition: inszt_adc.c:13495

DRV_SPI_BUFFER_EVENT
DRV_SPI_BUFFER_EVENT
Definition: inszt_adc.c:26399

qqoutput2
static void qqoutput2(FILEPOINT char *s, int i, int j)
Definition: inszt_adc.c:27931

PLIB_PORTS_ChannelChangeNoticePullDownDisable
void PLIB_PORTS_ChannelChangeNoticePullDownDisable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_DATA_MASK mask)

PLIB_USART_BRGClockSourceGet
USART_BRG_CLOCK_SOURCE PLIB_USART_BRGClockSourceGet(USART_MODULE_ID index)

DRV_USART_TRANSFER_STATUS
DRV_USART_TRANSFER_STATUS
Definition: inszt_adc.c:15489

DRV_TMR_OPERATION_MODE
DRV_TMR_OPERATION_MODE
Definition: inszt_adc.c:1848

ADC_Tasks
void ADC_Tasks(void)
Definition: inszt_adc.c:27740

SYS_DMA_CHANNEL_OPERATION_MODE_CRC
Definition: inszt_adc.c:13429

PLIB_USART_TransmitterBreakSend
void PLIB_USART_TransmitterBreakSend(USART_MODULE_ID index)

SYS_DMA_CHANNEL_OP_MODE_CHAIN_LOW
Definition: inszt_adc.c:13405

DRV_TMR_DIVIDER_RANGE::dividerMin
uint32_t dividerMin
Definition: inszt_adc.c:1875

SYS_PORTS_Set
void SYS_PORTS_Set(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_DATA_TYPE value, PORTS_DATA_MASK mask)

PLIB_DMA_ExistsCRCByteOrder
bool PLIB_DMA_ExistsCRCByteOrder(DMA_MODULE_ID index)

ADC_DATA::ADCInt
bool ADCInt
Definition: adc.h:91

PLIB_USART_ReceiverAddressAutoDetectEnable
void PLIB_USART_ReceiverAddressAutoDetectEnable(USART_MODULE_ID index, int8_t Mask)

SYS_DMA_CHANNEL_IGNORE_MATCH
SYS_DMA_CHANNEL_IGNORE_MATCH
Definition: inszt_adc.c:13316

DRV_USART_INIT::brgClock
uint32_t brgClock
Definition: inszt_adc.c:15551

_DRV_SPI_INIT::framePulseDirection
SPI_FRAME_PULSE_DIRECTION framePulseDirection
Definition: inszt_adc.c:26553

DRV_SPI_MODE_MASTER
Definition: inszt_adc.c:26425

PLIB_DMA_ChannelXChainDisable
void PLIB_DMA_ChannelXChainDisable(DMA_MODULE_ID index, DMA_CHANNEL channel)

PLIB_SPI_CommunicationWidthSelect
void PLIB_SPI_CommunicationWidthSelect(SPI_MODULE_ID index, SPI_COMMUNICATION_WIDTH width)

DRV_TMR4_CounterFrequencyGet
uint32_t DRV_TMR4_CounterFrequencyGet(void)

DRV_TMR1_StopInIdleDisable
void DRV_TMR1_StopInIdleDisable(void)

DRV_SPI_BUFFER_EVENT_ERROR
Definition: inszt_adc.c:26409

PLIB_PORTS_PinSlewRateGet
PORTS_PIN_SLEW_RATE PLIB_PORTS_PinSlewRateGet(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

DRV_USART_OPERATION_MODE_DATA
Definition: inszt_adc.c:15404

PLIB_SPI_BufferRead16bit
uint16_t PLIB_SPI_BufferRead16bit(SPI_MODULE_ID index)

PLIB_DMA_ChannelXDataSizeSelect
void PLIB_DMA_ChannelXDataSizeSelect(DMA_MODULE_ID index, DMA_CHANNEL channel, DMA_CHANNEL_DATA_SIZE channelDataSize)

adc_63zscanf
static int adc_63zscanf(char *qqscan_str)
Definition: inszt_adc.c:27863

PLIB_DMA_StartTransferSet
void PLIB_DMA_StartTransferSet(DMA_MODULE_ID index, DMA_CHANNEL channel)

DRV_TMR4_CounterClear
void DRV_TMR4_CounterClear(void)

SYS_DMA_ERROR
SYS_DMA_ERROR
Definition: inszt_adc.c:13491

DRV_TMR4_CounterValueGet
uint32_t DRV_TMR4_CounterValueGet(void)

PLIB_DMA_ExistsChannelXCellSize
bool PLIB_DMA_ExistsChannelXCellSize(DMA_MODULE_ID index)

_DRV_SPI_INIT::dummyByteValue
uint32_t dummyByteValue
Definition: inszt_adc.c:26589

PLIB_SPI_FIFODisable
void PLIB_SPI_FIFODisable(SPI_MODULE_ID index)

DRV_IO_INTENT_BLOCKING
Definition: inszt_adc.c:991

SYSTEM_OBJECTS::spiObjectIdx1
SYS_MODULE_OBJ spiObjectIdx1
Definition: inszt_adc.c:27670

PLIB_DMA_CRCDataRead
uint32_t PLIB_DMA_CRCDataRead(DMA_MODULE_ID index)

SYS_DMA_SIDL
SYS_DMA_SIDL
Definition: inszt_adc.c:13275

_DRV_SPI_CLIENT_DATA::baudRate
uint32_t baudRate
Definition: inszt_adc.c:26628

gblErrLvl
SYS_ERROR_LEVEL gblErrLvl

PLIB_PORTS_ChannelChangeNoticeMethodSelect
void PLIB_PORTS_ChannelChangeNoticeMethodSelect(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_CHANGE_NOTICE_METHOD changeNoticeMethod)

qqqqinitialise
static void qqqqinitialise(int ii)
Definition: inszt_adc.c:27964

SYS_DMA_CHANNEL_CRC_MODE
SYS_DMA_CHANNEL_CRC_MODE
Definition: inszt_adc.c:13335

SYS_DMA_CHANNEL_IGNORE_MATCH_ENABLE
Definition: inszt_adc.c:13322

PLIB_USART_ExistsBaudRate
bool PLIB_USART_ExistsBaudRate(USART_MODULE_ID index)

ldra_void_function
void(* ldra_void_function)()
Definition: inszt_adc.c:114

PLIB_DMA_StopInIdleEnable
void PLIB_DMA_StopInIdleEnable(DMA_MODULE_ID index)

DRV_HANDLE
uintptr_t DRV_HANDLE
Definition: inszt_adc.c:1108

DRV_SPIn_ReceiverBufferIsFull
bool DRV_SPIn_ReceiverBufferIsFull(void)

_DRV_SPI_INIT::spiProtocolType
DRV_SPI_PROTOCOL_TYPE spiProtocolType
Definition: inszt_adc.c:26545

PLIB_PORTS_RemapInput
void PLIB_PORTS_RemapInput(PORTS_MODULE_ID index, PORTS_REMAP_INPUT_FUNCTION inputFunction, PORTS_REMAP_INPUT_PIN remapInputPin)

DRV_CLIENT_STATUS_READY_EXTENDED
Definition: inszt_adc.c:1034

PLIB_USART_TransmitterIdleIsLowDisable
void PLIB_USART_TransmitterIdleIsLowDisable(USART_MODULE_ID index)

PLIB_PORTS_Clear
void PLIB_PORTS_Clear(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_DATA_MASK clearMask)

DRV_USART_CLIENT_STATUS_READY
Definition: inszt_adc.c:15475

PLIB_SPI_ReceiverOverflowClear
void PLIB_SPI_ReceiverOverflowClear(SPI_MODULE_ID index)

PLIB_SPI_ExistsFrameSyncPulseDirection
bool PLIB_SPI_ExistsFrameSyncPulseDirection(SPI_MODULE_ID index)

DRV_TMR3_Start
bool DRV_TMR3_Start(void)

PLIB_PORTS_ChannelChangeNoticeEdgeEnable
void PLIB_PORTS_ChannelChangeNoticeEdgeEnable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_DATA_MASK edgeRisingMask, PORTS_DATA_MASK edgeFallingMask)

_DRV_SPI_INIT::framePulseWidth
SPI_FRAME_PULSE_WIDTH framePulseWidth
Definition: inszt_adc.c:26557

SYS_DMA_CHANNEL_IGNORE_MATCH_DISABLE
Definition: inszt_adc.c:13320

PLIB_USART_ExistsReceiver9Bits
bool PLIB_USART_ExistsReceiver9Bits(USART_MODULE_ID index)

ADC
ADC_DATA ADC
Definition: inszt_adc.c:27720

SYSTEM_OBJECTS::drvTmr2
SYS_MODULE_OBJ drvTmr2
Definition: inszt_adc.c:27662

PLIB_DMA_ChannelXChainToHigher
void PLIB_DMA_ChannelXChainToHigher(DMA_MODULE_ID index, DMA_CHANNEL channel)

_DRV_SPI_INIT::baudRate
uint32_t baudRate
Definition: inszt_adc.c:26572

DRV_USART_ReadByte
uint8_t DRV_USART_ReadByte(const DRV_HANDLE handle)

DRV_USART_ClientStatus
DRV_USART_CLIENT_STATUS DRV_USART_ClientStatus(DRV_HANDLE handle)

SYS_DMA_CHANNEL_OP_MODE_MATCH_ABORT
Definition: inszt_adc.c:13392

SYS_PORTS_DirectionGet
PORTS_DATA_MASK SYS_PORTS_DirectionGet(PORTS_MODULE_ID index, PORTS_CHANNEL channel)

DRV_ADCHS_NUMBER_OF_MODULES
Definition: inszt_adc.c:1513

PLIB_USART_AddressMaskGet
uint8_t PLIB_USART_AddressMaskGet(USART_MODULE_ID index)

DRV_TMR1_CounterClear
void DRV_TMR1_CounterClear(void)

PLIB_USART_ExistsReceiver
bool PLIB_USART_ExistsReceiver(USART_MODULE_ID index)

PLIB_USART_BaudRateAutoDetectEnable
void PLIB_USART_BaudRateAutoDetectEnable(USART_MODULE_ID index)

DRV_TMR_CLIENT_STATUS_INVALID
Definition: inszt_adc.c:1805

DRV_PMP0_ModeConfig
void DRV_PMP0_ModeConfig(void)

PLIB_SPI_AudioCommunicationWidthSelect
void PLIB_SPI_AudioCommunicationWidthSelect(SPI_MODULE_ID index, SPI_AUDIO_COMMUNICATION_WIDTH mode)

PLIB_SPI_ExistsAudioTransmitMode
bool PLIB_SPI_ExistsAudioTransmitMode(SPI_MODULE_ID index)

DRV_USART_BYTE_EVENT_HANDLER
void(* DRV_USART_BYTE_EVENT_HANDLER)(const SYS_MODULE_INDEX index)
Definition: inszt_adc.c:15228

PLIB_PORTS_PinWrite
void PLIB_PORTS_PinWrite(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos, bool value)

DRV_USART_LINE_CONTROL_8ODD2
Definition: inszt_adc.c:15339

SYS_PORTS_ChangeNotificationPullUpDisable
void SYS_PORTS_ChangeNotificationPullUpDisable(PORTS_MODULE_ID index, PORTS_CHANGE_NOTICE_PIN pinNum)

SYS_PORTS_Write
void SYS_PORTS_Write(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_DATA_TYPE value)

SYS_ERROR_FATAL
Definition: inszt_adc.c:17552

PLIB_USART_ReceiverParityErrorHasOccurred
bool PLIB_USART_ReceiverParityErrorHasOccurred(USART_MODULE_ID index)

PLIB_DMA_ChannelXPatternLengthGet
DMA_PATTERN_LENGTH PLIB_DMA_ChannelXPatternLengthGet(DMA_MODULE_ID index, DMA_CHANNEL dmaChannel)

QQQindicator
int QQQindicator
Definition: inszt_main.c:104

DRV_TMR_GateModeClear
bool DRV_TMR_GateModeClear(DRV_HANDLE handle)

SYS_PORTS_ChangeNotificationInIdleModeDisable
void SYS_PORTS_ChangeNotificationInIdleModeDisable(PORTS_MODULE_ID index)

PLIB_DMA_ChannelXCellSizeSet
void PLIB_DMA_ChannelXCellSizeSet(DMA_MODULE_ID index, DMA_CHANNEL dmaChannel, uint16_t CellSize)

PLIB_USART_Disable
void PLIB_USART_Disable(USART_MODULE_ID index)

DRV_TMR3_Close
static void DRV_TMR3_Close(void)
Definition: inszt_adc.c:4075

DRV_TMR_INIT::clockSource
DRV_TMR_CLK_SOURCES clockSource
Definition: inszt_adc.c:1900

PLIB_SPI_ExistsReceiverOverflow
bool PLIB_SPI_ExistsReceiverOverflow(SPI_MODULE_ID index)

qqnull_params
#define qqnull_params
Definition: inszt_adc.c:27842

PLIB_SPI_TransmitUnderRunStatusClear
void PLIB_SPI_TransmitUnderRunStatusClear(SPI_MODULE_ID index)

DRV_TMR_AlarmPeriodSet
void DRV_TMR_AlarmPeriodSet(DRV_HANDLE handle, uint32_t value)

SYS_PORTS_PIN_DIRECTION
SYS_PORTS_PIN_DIRECTION
Definition: inszt_adc.c:21888

DRV_IO_BUFFER_TYPE_WRITE
Definition: inszt_adc.c:1084

PLIB_DMA_ChannelXTriggerIsEnabled
bool PLIB_DMA_ChannelXTriggerIsEnabled(DMA_MODULE_ID index, DMA_CHANNEL channel, DMA_CHANNEL_TRIGGER_TYPE trigger)

DRV_TMR2_Close
static void DRV_TMR2_Close(void)
Definition: inszt_adc.c:3965

PLIB_DMA_ChannelXAddressModeGet
DMA_CHANNEL_ADDRESSING_MODE PLIB_DMA_ChannelXAddressModeGet(DMA_MODULE_ID index, DMA_CHANNEL channel)

DRV_TMR1_CounterValueSet
void DRV_TMR1_CounterValueSet(uint32_t value)

PLIB_DMA_ChannelXTriggerDisable
void PLIB_DMA_ChannelXTriggerDisable(DMA_MODULE_ID index, DMA_CHANNEL channel, DMA_CHANNEL_TRIGGER_TYPE trigger)

PLIB_PORTS_PinClear
void PLIB_PORTS_PinClear(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

PLIB_PORTS_PinChangeNoticePerPortEnable
void PLIB_PORTS_PinChangeNoticePerPortEnable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

PLIB_SPI_PinDisable
void PLIB_SPI_PinDisable(SPI_MODULE_ID index, SPI_PIN pin)

DRV_USART0_ReceiverBufferIsEmpty
bool DRV_USART0_ReceiverBufferIsEmpty(void)

DRV_TMR_CounterFrequencyGet
uint32_t DRV_TMR_CounterFrequencyGet(DRV_HANDLE handle)

PLIB_USART_ExistsReceiverEnable
bool PLIB_USART_ExistsReceiverEnable(USART_MODULE_ID index)

DRV_USART_INIT::baud
uint32_t baud
Definition: inszt_adc.c:15559

DRV_TMR_AlarmDeregister
void DRV_TMR_AlarmDeregister(DRV_HANDLE handle)

PLIB_DMA_CRCPolynomialLengthSet
void PLIB_DMA_CRCPolynomialLengthSet(DMA_MODULE_ID index, uint8_t polyLength)

PLIB_USART_RunInOverflowDisable
void PLIB_USART_RunInOverflowDisable(USART_MODULE_ID index)

qqqbranches
#define qqqbranches
Definition: inszt_adc.c:27820

PLIB_SPI_Exists16bitBuffer
bool PLIB_SPI_Exists16bitBuffer(SPI_MODULE_ID index)

DRV_TMR2_StopInIdleDisable
void DRV_TMR2_StopInIdleDisable(void)

SYS_PORTS_Initialize
void SYS_PORTS_Initialize()

PLIB_SPI_Exists32bitBuffer
bool PLIB_SPI_Exists32bitBuffer(SPI_MODULE_ID index)

PLIB_PORTS_ExistsSlewRateControl
bool PLIB_PORTS_ExistsSlewRateControl(PORTS_MODULE_ID index)

DRV_IO_INTENT_EXCLUSIVE
Definition: inszt_adc.c:999

PLIB_PORTS_ExistsRemapOutput
bool PLIB_PORTS_ExistsRemapOutput(PORTS_MODULE_ID index)

PLIB_DMA_CRCByteOrderSelect
void PLIB_DMA_CRCByteOrderSelect(DMA_MODULE_ID index, DMA_CRC_BYTE_ORDER byteOrder)

PLIB_SPI_SlaveSelectDisable
void PLIB_SPI_SlaveSelectDisable(SPI_MODULE_ID index)

PLIB_PORTS_CnPinsDisable
void PLIB_PORTS_CnPinsDisable(PORTS_MODULE_ID index, PORTS_CN_PIN cnPins)

PLIB_SPI_IsBusy
bool PLIB_SPI_IsBusy(SPI_MODULE_ID index)

qqqtotalreset
void qqqtotalreset(void)
Definition: inszt_main.c:7067

PLIB_USART_RunInSleepModeEnable
void PLIB_USART_RunInSleepModeEnable(USART_MODULE_ID index)

PLIB_SPI_ReceiverHasOverflowed
bool PLIB_SPI_ReceiverHasOverflowed(SPI_MODULE_ID index)

DRV_TMR0_ClockSet
bool DRV_TMR0_ClockSet(DRV_TMR_CLK_SOURCES clockSource, TMR_PRESCALE prescale)

DRV_USART_TRANSFER_STATUS_TRANSMIT_FULL
Definition: inszt_adc.c:15503

DRV_TMR2_CounterValueGet
uint32_t DRV_TMR2_CounterValueGet(void)

SYS_PORTS_ChangeNotificationEnable
void SYS_PORTS_ChangeNotificationEnable(PORTS_MODULE_ID index, PORTS_CHANGE_NOTICE_PIN pinNum, SYS_PORTS_PULLUP_PULLDOWN_STATUS value)

PLIB_SPI_FIFOCountGet
uint8_t PLIB_SPI_FIFOCountGet(SPI_MODULE_ID index, SPI_FIFO_TYPE type)

DRV_ADC_ID_1
Definition: inszt_adc.c:1512

DRV_TMR_INIT::tmrId
TMR_MODULE_ID tmrId
Definition: inszt_adc.c:1898

DRV_TMR2_Status
static SYS_STATUS DRV_TMR2_Status(void)
Definition: inszt_adc.c:3933

PLIB_DMA_ChannelXPatternIgnoreByteIsEnabled
bool PLIB_DMA_ChannelXPatternIgnoreByteIsEnabled(DMA_MODULE_ID index, DMA_CHANNEL channel)

PLIB_SPI_ExistsBaudRate
bool PLIB_SPI_ExistsBaudRate(SPI_MODULE_ID index)

PLIB_SPI_FIFOEnable
void PLIB_SPI_FIFOEnable(SPI_MODULE_ID index)

DRV_USART_TasksReceive
void DRV_USART_TasksReceive(SYS_MODULE_OBJ object)

DRV_USART0_TransmitBufferIsFull
bool DRV_USART0_TransmitBufferIsFull(void)

DRV_USART0_TasksReceive
void DRV_USART0_TasksReceive(void)

PLIB_PORTS_ExistsLatchRead
bool PLIB_PORTS_ExistsLatchRead(PORTS_MODULE_ID index)

PLIB_DMA_ChannelXSourceAddressModeSelect
void PLIB_DMA_ChannelXSourceAddressModeSelect(DMA_MODULE_ID index, DMA_CHANNEL channel, DMA_SOURCE_ADDRESSING_MODE sourceAddressMode)

DRV_USART_HANDSHAKE
DRV_USART_HANDSHAKE
Definition: inszt_adc.c:15241

DRV_SPI_MODE
DRV_SPI_MODE
Definition: inszt_adc.c:26421

PLIB_PORTS_ChangeNoticeInIdleEnable
void PLIB_PORTS_ChangeNoticeInIdleEnable(PORTS_MODULE_ID index)

DRV_USART_ERROR_ADDRESS
Definition: inszt_adc.c:15450

_DRV_SPI_INIT::bufferType
DRV_SPI_BUFFER_TYPE bufferType
Definition: inszt_adc.c:26574

DRV_USART_LINE_CONTROL_8NONE1
Definition: inszt_adc.c:15319

DRV_TMR_CLKSOURCE_EXTERNAL_ASYNCHRONOUS
Definition: inszt_adc.c:1710

DRV_USART0_TasksError
void DRV_USART0_TasksError(void)

DRV_TMR_INIT::asyncWriteEnable
bool asyncWriteEnable
Definition: inszt_adc.c:1914

ADC_STATE_WAIT
Definition: inszt_adc.c:235

DRV_TMR_Close
void DRV_TMR_Close(DRV_HANDLE handle)

PLIB_PORTS_Toggle
void PLIB_PORTS_Toggle(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_DATA_MASK toggleMask)

DRV_IC0_Initialize
void DRV_IC0_Initialize(void)

PLIB_USART_HandshakeModeSelect
void PLIB_USART_HandshakeModeSelect(USART_MODULE_ID index, USART_HANDSHAKE_MODE handshakeConfig)

PLIB_PORTS_ExistsChangeNoticeInIdle
bool PLIB_PORTS_ExistsChangeNoticeInIdle(PORTS_MODULE_ID index)

PLIB_USART_IrDADisable
void PLIB_USART_IrDADisable(USART_MODULE_ID index)

SYS_DMA_CHANNEL_OPERATION_MODE_CRC::writeOrder
SYS_DMA_CRC_WRITE_ORDER writeOrder
Definition: inszt_adc.c:13449

DRV_TMR0_StopInIdleEnable
void DRV_TMR0_StopInIdleEnable(void)

PLIB_PORTS_ChannelChangeNoticeDisable
void PLIB_PORTS_ChannelChangeNoticeDisable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_DATA_MASK mask)

DRV_TMR_Status
SYS_STATUS DRV_TMR_Status(SYS_MODULE_OBJ object)

PLIB_DMA_ChannelXDisabledDisablesEvents
void PLIB_DMA_ChannelXDisabledDisablesEvents(DMA_MODULE_ID index, DMA_CHANNEL channel)

PLIB_PORTS_DirectionGet
PORTS_DATA_MASK PLIB_PORTS_DirectionGet(PORTS_MODULE_ID index, PORTS_CHANNEL channel)

DRV_USART_LINE_CONTROL_8EVEN2
Definition: inszt_adc.c:15331

PLIB_SPI_FramedCommunicationDisable
void PLIB_SPI_FramedCommunicationDisable(SPI_MODULE_ID index)

PLIB_DMA_ChannelXAutoIsEnabled
bool PLIB_DMA_ChannelXAutoIsEnabled(DMA_MODULE_ID index, DMA_CHANNEL channel)

PLIB_DMA_ChannelXReloadIsEnabled
bool PLIB_DMA_ChannelXReloadIsEnabled(DMA_MODULE_ID index, DMA_CHANNEL channel)

SYSTEM_OBJECTS::drvTmr4
SYS_MODULE_OBJ drvTmr4
Definition: inszt_adc.c:27664

DRV_SPI_Deinitialize
void DRV_SPI_Deinitialize(SYS_MODULE_OBJ object)

DRV_SPI_BufferStatus
DRV_SPI_BUFFER_EVENT DRV_SPI_BufferStatus(DRV_SPI_BUFFER_HANDLE bufferHandle)

PLIB_PORTS_ChangeNoticePullUpDisable
void PLIB_PORTS_ChangeNoticePullUpDisable(PORTS_MODULE_ID index, PORTS_CHANGE_NOTICE_PIN pinNum)

DRV_TMR4_Status
static SYS_STATUS DRV_TMR4_Status(void)
Definition: inszt_adc.c:4153

adc_63zqendz
static int adc_63zqendz(int qqqi)
Definition: inszt_adc.c:28032

PLIB_USART_LoopbackEnable
void PLIB_USART_LoopbackEnable(USART_MODULE_ID index)

DRV_USART_CLIENT_STATUS
DRV_USART_CLIENT_STATUS
Definition: inszt_adc.c:15464

PLIB_PORTS_ChangeNoticePullUpPerPortEnable
void PLIB_PORTS_ChangeNoticePullUpPerPortEnable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

PLIB_DMA_ChannelPrioritySelect
void PLIB_DMA_ChannelPrioritySelect(DMA_MODULE_ID index, DMA_CHANNEL_PRIORITY channelPriority)

PLIB_USART_ExistsEnable
bool PLIB_USART_ExistsEnable(USART_MODULE_ID index)

DRV_TMR3_Open
static void DRV_TMR3_Open(void)
Definition: inszt_adc.c:4054

PLIB_PORTS_PinSet
void PLIB_PORTS_PinSet(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

PLIB_USART_ExistsBaudRateAutoDetect
bool PLIB_USART_ExistsBaudRateAutoDetect(USART_MODULE_ID index)

DRV_IC_Capture16BitDataRead
uint16_t DRV_IC_Capture16BitDataRead(DRV_HANDLE handle)

PLIB_PORTS_ChannelChangeNoticePullUpDisable
void PLIB_PORTS_ChannelChangeNoticePullUpDisable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_DATA_MASK mask)

DRV_ADC0_Close
void DRV_ADC0_Close(void)

SYSTEM_OBJECTS::drvPMP0
SYS_MODULE_OBJ drvPMP0
Definition: inszt_adc.c:27666

SYS_DMA_Resume
void SYS_DMA_Resume(void)

DRV_ADC1_Close
void DRV_ADC1_Close(void)

DRV_ADC_Start
void DRV_ADC_Start(void)

DRV_TMR1_PeriodValueGet
uint32_t DRV_TMR1_PeriodValueGet(void)

PLIB_USART_ExistsTransmitterBreak
bool PLIB_USART_ExistsTransmitterBreak(USART_MODULE_ID index)

DRV_TMR2_Start
bool DRV_TMR2_Start(void)

DRV_IC_Stop
void DRV_IC_Stop(DRV_HANDLE handle)

PLIB_USART_BaudSetAndEnable
void PLIB_USART_BaudSetAndEnable(USART_MODULE_ID index, uint32_t systemClock, uint32_t baud)

PLIB_DMA_ExistsChannelXDestinationPointer
bool PLIB_DMA_ExistsChannelXDestinationPointer(DMA_MODULE_ID index)

PLIB_DMA_ChannelXDataSizeGet
DMA_CHANNEL_DATA_SIZE PLIB_DMA_ChannelXDataSizeGet(DMA_MODULE_ID index, DMA_CHANNEL channel)

PLIB_DMA_ChannelXNullWriteModeIsEnabled
bool PLIB_DMA_ChannelXNullWriteModeIsEnabled(DMA_MODULE_ID index, DMA_CHANNEL channel)

DRV_IO_INTENT
DRV_IO_INTENT
Definition: inszt_adc.c:975

DRV_USART_HANDSHAKE_NONE
Definition: inszt_adc.c:15253

_DRV_SPI_INIT::operationStarting
DRV_SPI_BUFFER_EVENT_HANDLER operationStarting
Definition: inszt_adc.c:26603

DRV_TMR_CLKSOURCE_INTERNAL
Definition: inszt_adc.c:1698

PLIB_PORTS_ExistsPortsOpenDrain
bool PLIB_PORTS_ExistsPortsOpenDrain(PORTS_MODULE_ID index)

PLIB_SPI_ExistsReceiveBufferStatus
bool PLIB_SPI_ExistsReceiveBufferStatus(SPI_MODULE_ID index)

PLIB_PORTS_PinModePerPortSelect
void PLIB_PORTS_PinModePerPortSelect(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos, PORTS_PIN_MODE mode)

DRV_USART_INIT::dmaInterruptTransmit
INT_SOURCE dmaInterruptTransmit
Definition: inszt_adc.c:15601

SYS_PORTS_PinPullUpDisable
void SYS_PORTS_PinPullUpDisable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

PLIB_USART_AddressMaskSet
void PLIB_USART_AddressMaskSet(USART_MODULE_ID index, uint8_t mask)

PLIB_DMA_CRCEnable
void PLIB_DMA_CRCEnable(DMA_MODULE_ID index)

DRV_USART_INIT::queueSizeReceive
unsigned int queueSizeReceive
Definition: inszt_adc.c:15584

SYS_DMA_ChannelForceStart
void SYS_DMA_ChannelForceStart(SYS_DMA_CHANNEL_HANDLE handle)

PLIB_DMA_SuspendIsEnabled
bool PLIB_DMA_SuspendIsEnabled(DMA_MODULE_ID index)

DRV_SPI_BUFFER_TYPE_ENHANCED
Definition: inszt_adc.c:26353

PLIB_USART_ExistsTransmitterBufferFullStatus
bool PLIB_USART_ExistsTransmitterBufferFullStatus(USART_MODULE_ID index)

PLIB_SPI_ReceiverBufferIsFull
bool PLIB_SPI_ReceiverBufferIsFull(SPI_MODULE_ID index)

DRV_USART_LINE_CONTROL_9NONE1
Definition: inszt_adc.c:15323

PLIB_USART_ExistsTransmitterEmptyStatus
bool PLIB_USART_ExistsTransmitterEmptyStatus(USART_MODULE_ID index)

PLIB_SPI_ExistsFIFOControl
bool PLIB_SPI_ExistsFIFOControl(SPI_MODULE_ID index)

QQQfcn_ptr_num
int QQQfcn_ptr_num
Definition: inszt_main.c:151

DRV_USART_LINE_CONTROL_8NONE2
Definition: inszt_adc.c:15343

SYS_PORTS_PinPullDownEnable
void SYS_PORTS_PinPullDownEnable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

DRV_USART_BufferCompletedBytesGet
size_t DRV_USART_BufferCompletedBytesGet(DRV_USART_BUFFER_HANDLE bufferHandle)

DRV_USART_INIT::handshake
DRV_USART_HANDSHAKE handshake
Definition: inszt_adc.c:15562

PLIB_USART_ReceiverAddressDetectDisable
void PLIB_USART_ReceiverAddressDetectDisable(USART_MODULE_ID index)

DRV_TMR_DividerRangeGet
DRV_TMR_OPERATION_MODE DRV_TMR_DividerRangeGet(DRV_HANDLE handle, DRV_TMR_DIVIDER_RANGE *pDivRange)

SYS_DMA_CHANNEL_TRANSFER_EVENT_HANDLER
void(* SYS_DMA_CHANNEL_TRANSFER_EVENT_HANDLER)(SYS_DMA_TRANSFER_EVENT event, SYS_DMA_CHANNEL_HANDLE handle, uintptr_t contextHandle)
Definition: inszt_adc.c:13629

DRV_USART_ReceiverBufferSizeGet
unsigned int DRV_USART_ReceiverBufferSizeGet(const DRV_HANDLE handle)

DRV_TMR_OPERATION_MODE_32_BIT
Definition: inszt_adc.c:1857

PLIB_PORTS_ChangeNoticeInIdlePerPortEnable
void PLIB_PORTS_ChangeNoticeInIdlePerPortEnable(PORTS_MODULE_ID index, PORTS_CHANNEL channel)

DRV_USART_BUFFER_EVENT_COMPLETE
Definition: inszt_adc.c:15100

DRV_TMR4_Initialize
void DRV_TMR4_Initialize(void)

DRV_TMR_CALLBACK
void(* DRV_TMR_CALLBACK)(uintptr_t context, uint32_t alarmCount)
Definition: inszt_adc.c:1928

PLIB_USART_LoopbackDisable
void PLIB_USART_LoopbackDisable(USART_MODULE_ID index)

DRV_IC0_BufferIsEmpty
bool DRV_IC0_BufferIsEmpty(void)

PLIB_USART_ExistsReceiverAddressDetect
bool PLIB_USART_ExistsReceiverAddressDetect(USART_MODULE_ID index)

DRV_TMR0_DeInitialize
static void DRV_TMR0_DeInitialize(void)
Definition: inszt_adc.c:3704

PLIB_DMA_ChannelXDisabledEnablesEvents
void PLIB_DMA_ChannelXDisabledEnablesEvents(DMA_MODULE_ID index, DMA_CHANNEL channel)

PLIB_SPI_AudioProtocolModeSelect
void PLIB_SPI_AudioProtocolModeSelect(SPI_MODULE_ID index, SPI_AUDIO_PROTOCOL mode)

SYS_DMA_ChannelErrorGet
SYS_DMA_ERROR SYS_DMA_ChannelErrorGet(SYS_DMA_CHANNEL_HANDLE handle)

qqqtotalupload
void qqqtotalupload(void)
Definition: inszt_main.c:7054

PLIB_SPI_BufferClear
void PLIB_SPI_BufferClear(SPI_MODULE_ID index)

PLIB_SPI_ExistsSlaveSelectControl
bool PLIB_SPI_ExistsSlaveSelectControl(SPI_MODULE_ID index)

PLIB_DMA_CRCXOREnableGet
uint32_t PLIB_DMA_CRCXOREnableGet(DMA_MODULE_ID index)

DRV_TMR_CounterValueSet
void DRV_TMR_CounterValueSet(DRV_HANDLE handle, uint32_t counterPeriod)

SYS_DMA_CHANNEL_OP_MODE
SYS_DMA_CHANNEL_OP_MODE
Definition: inszt_adc.c:13381

PLIB_USART_AddressGet
uint8_t PLIB_USART_AddressGet(USART_MODULE_ID index)

PLIB_USART_OperationModeSelect
void PLIB_USART_OperationModeSelect(USART_MODULE_ID index, USART_OPERATION_MODE operationmode)

_DRV_SPI_INIT::framePulseEdge
SPI_FRAME_PULSE_EDGE framePulseEdge
Definition: inszt_adc.c:26555

DRV_USART_BUFFER_EVENT_ABORT
Definition: inszt_adc.c:15104

PLIB_USART_ExistsReceiverInterruptMode
bool PLIB_USART_ExistsReceiverInterruptMode(USART_MODULE_ID index)

DRV_SPI_PROTOCOL_TYPE_STANDARD
Definition: inszt_adc.c:26371

PLIB_DMA_ChannelXBufferedDataIsWritten
bool PLIB_DMA_ChannelXBufferedDataIsWritten(DMA_MODULE_ID index, DMA_CHANNEL channel)

PLIB_PORTS_ChangeNoticeEnable
void PLIB_PORTS_ChangeNoticeEnable(PORTS_MODULE_ID index)

PLIB_USART_ExistsTransmitter9BitsSend
bool PLIB_USART_ExistsTransmitter9BitsSend(USART_MODULE_ID index)

DRV_TMR_Tasks
void DRV_TMR_Tasks(SYS_MODULE_OBJ object)

SYS_DMA_ChannelSetupMatchAbortMode
void SYS_DMA_ChannelSetupMatchAbortMode(SYS_DMA_CHANNEL_HANDLE handle, uint16_t pattern, DMA_PATTERN_LENGTH length, SYS_DMA_CHANNEL_IGNORE_MATCH ignore, uint8_t ignorePattern)

DRV_TMR3_Tasks
static void DRV_TMR3_Tasks(void)
Definition: inszt_adc.c:4115

DRV_TMR1_ClockSet
bool DRV_TMR1_ClockSet(DRV_TMR_CLK_SOURCES clockSource, TMR_PRESCALE prescale)

_DRV_SPI_INIT::spiId
SPI_MODULE_ID spiId
Definition: inszt_adc.c:26537

PLIB_DMA_ExistsCRCWriteByteOrder
bool PLIB_DMA_ExistsCRCWriteByteOrder(DMA_MODULE_ID index)

DRV_SPI_CLOCK_MODE_IDLE_LOW_EDGE_FALL
Definition: inszt_adc.c:26314

PLIB_USART_TransmitterByteSend
void PLIB_USART_TransmitterByteSend(USART_MODULE_ID index, int8_t data)

DRV_TMR2_CounterValueSet
void DRV_TMR2_CounterValueSet(uint32_t value)

SYS_DMA_CHANNEL_OP_MODE_BASIC
Definition: inszt_adc.c:13386

PLIB_SPI_MasterEnable
void PLIB_SPI_MasterEnable(SPI_MODULE_ID index)

DRV_SPI_Open
DRV_HANDLE DRV_SPI_Open(const SYS_MODULE_INDEX drvIndex, const DRV_IO_INTENT ioIntent)

DRV_USART_BAUD_SET_SUCCESS
Definition: inszt_adc.c:15274

DRV_USART_INIT::flags
DRV_USART_INIT_FLAGS flags
Definition: inszt_adc.c:15546

PLIB_USART_BRGClockSourceSelect
void PLIB_USART_BRGClockSourceSelect(USART_MODULE_ID index, USART_BRG_CLOCK_SOURCE brgClockSource)

DRV_TMR3_Initialize
void DRV_TMR3_Initialize(void)

PLIB_PORTS_PinDirectionInputSet
void PLIB_PORTS_PinDirectionInputSet(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

PLIB_PORTS_ChannelChangeNoticePullDownEnable
void PLIB_PORTS_ChannelChangeNoticePullDownEnable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_DATA_MASK mask)

DRV_IC_Open
#define DRV_IC_Open(drvIndex, intent)
Definition: inszt_adc.c:1417

PLIB_SPI_ErrorInterruptEnable
void PLIB_SPI_ErrorInterruptEnable(SPI_MODULE_ID index, SPI_ERROR_INTERRUPT error)

PLIB_DMA_CRCPolynomialLengthGet
uint8_t PLIB_DMA_CRCPolynomialLengthGet(DMA_MODULE_ID index)

PLIB_SPI_ExistsBusStatus
bool PLIB_SPI_ExistsBusStatus(SPI_MODULE_ID index)

DRV_USART_OPERATION_MODE_NORMAL
Definition: inszt_adc.c:15069

PLIB_PORTS_OpenDrainEnable
void PLIB_PORTS_OpenDrainEnable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_DATA_MASK mask)

DRV_USART_INIT::queueSizeTransmit
unsigned int queueSizeTransmit
Definition: inszt_adc.c:15589

DRV_TMR2_CounterFrequencyGet
uint32_t DRV_TMR2_CounterFrequencyGet(void)

SYS_DEBUG_INIT
Definition: inszt_adc.c:17592

SYS_DMA_ChannelTransferEventHandlerSet
void SYS_DMA_ChannelTransferEventHandlerSet(SYS_DMA_CHANNEL_HANDLE handle, const SYS_DMA_CHANNEL_TRANSFER_EVENT_HANDLER eventHandler, const uintptr_t contextHandle)

PLIB_USART_RunInSleepModeIsEnabled
bool PLIB_USART_RunInSleepModeIsEnabled(USART_MODULE_ID index)

DRV_PMP0_Write
void DRV_PMP0_Write(uint8_t data)

ADC_STATE_IDLE
Definition: inszt_adc.c:237

SYS_ERROR_LEVEL
SYS_ERROR_LEVEL
Definition: inszt_adc.c:17548

DRV_PMP0_Initialize
void DRV_PMP0_Initialize(void)

PLIB_DMA_ChannelXStartAddressOffsetGet
uint16_t PLIB_DMA_ChannelXStartAddressOffsetGet(DMA_MODULE_ID index, DMA_CHANNEL channel, DMA_ADDRESS_OFFSET_TYPE offset)

DRV_USART_BUFFER_HANDLE
uintptr_t DRV_USART_BUFFER_HANDLE
Definition: inszt_adc.c:15035

PLIB_PORTS_DirectionOutputSet
void PLIB_PORTS_DirectionOutputSet(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_DATA_MASK mask)

SYS_DMA_CHANNEL_OPERATION_MODE_CRC::bitOrder
DMA_CRC_BIT_ORDER bitOrder
Definition: inszt_adc.c:13444

PLIB_DMA_LastBusAccessIsWrite
bool PLIB_DMA_LastBusAccessIsWrite(DMA_MODULE_ID index)

DRV_TMR_GateModeSet
bool DRV_TMR_GateModeSet(DRV_HANDLE handle)

PLIB_DMA_ExistsCRC
bool PLIB_DMA_ExistsCRC(DMA_MODULE_ID index)

PLIB_USART_StopInIdleDisable
void PLIB_USART_StopInIdleDisable(USART_MODULE_ID index)

PLIB_SPI_ExistsMasterControl
bool PLIB_SPI_ExistsMasterControl(SPI_MODULE_ID index)

PLIB_SPI_ExistsReadDataSignStatus
bool PLIB_SPI_ExistsReadDataSignStatus(SPI_MODULE_ID index)

PLIB_PORTS_ChangeNoticePerPortTurnOn
void PLIB_PORTS_ChangeNoticePerPortTurnOn(PORTS_MODULE_ID index, PORTS_CHANNEL channel)

PLIB_SPI_BaudRateSet
void PLIB_SPI_BaudRateSet(SPI_MODULE_ID index, uint32_t clockFrequency, uint32_t baudRate)

PLIB_USART_ExistsWakeOnStart
bool PLIB_USART_ExistsWakeOnStart(USART_MODULE_ID index)

PLIB_SPI_TransmitBufferIsFull
bool PLIB_SPI_TransmitBufferIsFull(SPI_MODULE_ID index)

PLIB_DMA_ChannelXDestinationSizeGet
uint16_t PLIB_DMA_ChannelXDestinationSizeGet(DMA_MODULE_ID index, DMA_CHANNEL dmaChannel)

PLIB_DMA_ExistsCRCXOREnable
bool PLIB_DMA_ExistsCRCXOREnable(DMA_MODULE_ID index)

DRV_USART0_LineControlSet
DRV_USART_LINE_CONTROL_SET_RESULT DRV_USART0_LineControlSet(DRV_USART_LINE_CONTROL lineControlMode)

qqoutput4
static void qqoutput4(FILEPOINT char *s, int i, int j, int k, int l)
Definition: inszt_adc.c:27949

PLIB_DMA_ExistsChannelXPatternData
bool PLIB_DMA_ExistsChannelXPatternData(DMA_MODULE_ID index)

ADC_STATES
ADC_STATES
Definition: adc.h:55

SYS_DMA_TRANSFER_EVENT_ERROR
Definition: inszt_adc.c:13475

SYS_DMA_ChannelForceAbort
void SYS_DMA_ChannelForceAbort(SYS_DMA_CHANNEL_HANDLE handle)

PLIB_SPI_ExistsCommunicationWidth
bool PLIB_SPI_ExistsCommunicationWidth(SPI_MODULE_ID index)

DRV_TMR3_StopInIdleEnable
void DRV_TMR3_StopInIdleEnable(void)

_DRV_SPI_INIT::operationEnded
DRV_SPI_BUFFER_EVENT_HANDLER operationEnded
Definition: inszt_adc.c:26610

adc_63zzopen
#define adc_63zzopen
Definition: inszt_adc.c:76

PLIB_DMA_ExistsAbortTransfer
bool PLIB_DMA_ExistsAbortTransfer(DMA_MODULE_ID index)

DRV_TMR2_OperationModeGet
static DRV_TMR_OPERATION_MODE DRV_TMR2_OperationModeGet(void)
Definition: inszt_adc.c:3955

PLIB_PORTS_PinChangeNoticeDisable
void PLIB_PORTS_PinChangeNoticeDisable(PORTS_MODULE_ID index, PORTS_CHANGE_NOTICE_PIN pinNum)

PLIB_DMA_ChannelXAutoEnable
void PLIB_DMA_ChannelXAutoEnable(DMA_MODULE_ID index, DMA_CHANNEL channel)

_DRV_SPI_INIT::spiClk
CLK_BUSES_PERIPHERAL spiClk
Definition: inszt_adc.c:26570

PLIB_PORTS_ExistsChangeNotice
bool PLIB_PORTS_ExistsChangeNotice(PORTS_MODULE_ID index)

DRV_SPI_MODE_SLAVE
Definition: inszt_adc.c:26430

DRV_IC0_Start
void DRV_IC0_Start(void)

PLIB_DMA_ExistsChannelX
bool PLIB_DMA_ExistsChannelX(DMA_MODULE_ID index)

PLIB_SPI_StopInIdleDisable
void PLIB_SPI_StopInIdleDisable(SPI_MODULE_ID index)

PLIB_SPI_ExistsBuffer
bool PLIB_SPI_ExistsBuffer(SPI_MODULE_ID index)

DRV_TMR2_ClientStatus
DRV_TMR_CLIENT_STATUS DRV_TMR2_ClientStatus(void)

PLIB_USART_ExistsReceiverOverrunStatus
bool PLIB_USART_ExistsReceiverOverrunStatus(USART_MODULE_ID index)

SYS_DMA_CHANNEL_OP_MODE_AUTO
Definition: inszt_adc.c:13411

PLIB_SPI_FrameSyncPulseDirectionSelect
void PLIB_SPI_FrameSyncPulseDirectionSelect(SPI_MODULE_ID index, SPI_FRAME_PULSE_DIRECTION direction)

PLIB_DMA_ExistsCRCAppendMode
bool PLIB_DMA_ExistsCRCAppendMode(DMA_MODULE_ID index)

PLIB_DMA_ChannelXPatternDataSet
void PLIB_DMA_ChannelXPatternDataSet(DMA_MODULE_ID index, DMA_CHANNEL dmaChannel, uint16_t patternData)

SYSTEM_OBJECTS::spiObjectIdx0
SYS_MODULE_OBJ spiObjectIdx0
Definition: inszt_adc.c:27668

PLIB_DMA_ChannelXINTSourceFlagSet
void PLIB_DMA_ChannelXINTSourceFlagSet(DMA_MODULE_ID index, DMA_CHANNEL dmaChannel, DMA_INT_TYPE dmaINTSource)

PLIB_SPI_Disable
void PLIB_SPI_Disable(SPI_MODULE_ID index)

DRV_USART_INIT::lineControl
DRV_USART_LINE_CONTROL lineControl
Definition: inszt_adc.c:15555

PLIB_USART_ExistsReceiverParityErrorStatus
bool PLIB_USART_ExistsReceiverParityErrorStatus(USART_MODULE_ID index)

PLIB_PORTS_ChangeNoticeDisable
void PLIB_PORTS_ChangeNoticeDisable(PORTS_MODULE_ID index)

PLIB_PORTS_ExistsChannelChangeNoticeMethod
bool PLIB_PORTS_ExistsChannelChangeNoticeMethod(PORTS_MODULE_ID index)

SYS_PORTS_LatchedGet
PORTS_DATA_TYPE SYS_PORTS_LatchedGet(PORTS_MODULE_ID index, PORTS_CHANNEL channel)

DRV_TMR3_StopInIdleDisable
void DRV_TMR3_StopInIdleDisable(void)

PLIB_DMA_ChannelXPatternIgnoreGet
uint8_t PLIB_DMA_ChannelXPatternIgnoreGet(DMA_MODULE_ID index, DMA_CHANNEL channel)

PLIB_DMA_ChannelXAbortIRQSet
void PLIB_DMA_ChannelXAbortIRQSet(DMA_MODULE_ID index, DMA_CHANNEL channel, DMA_TRIGGER_SOURCE IRQ)

PLIB_DMA_ChannelXDestinationAddressModeGet
DMA_DESTINATION_ADDRESSING_MODE PLIB_DMA_ChannelXDestinationAddressModeGet(DMA_MODULE_ID index, DMA_CHANNEL channel)

PLIB_PORTS_Set
void PLIB_PORTS_Set(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_DATA_TYPE value, PORTS_DATA_MASK mask)

PLIB_DMA_CRCIsEnabled
bool PLIB_DMA_CRCIsEnabled(DMA_MODULE_ID index)

_DRV_SPI_INIT::commWidth
SPI_COMMUNICATION_WIDTH commWidth
Definition: inszt_adc.c:26563

DRV_TMR0_Status
static SYS_STATUS DRV_TMR0_Status(void)
Definition: inszt_adc.c:3713

PLIB_DMA_StopInIdleDisable
void PLIB_DMA_StopInIdleDisable(DMA_MODULE_ID index)

PLIB_PORTS_PinChangeNoticeEdgeHasOccurred
bool PLIB_PORTS_PinChangeNoticeEdgeHasOccurred(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

DRV_TMR_OPERATION_MODE_16_BIT
Definition: inszt_adc.c:1854

SYS_DMA_ChannelIsBusy
bool SYS_DMA_ChannelIsBusy(SYS_DMA_CHANNEL_HANDLE handle)

DRV_TMR1_Status
static SYS_STATUS DRV_TMR1_Status(void)
Definition: inszt_adc.c:3823

PLIB_USART_TransmitterIsEmpty
bool PLIB_USART_TransmitterIsEmpty(USART_MODULE_ID index)

PLIB_DMA_ExistsRecentAddress
bool PLIB_DMA_ExistsRecentAddress(DMA_MODULE_ID index)

PLIB_PORTS_PinToggle
void PLIB_PORTS_PinToggle(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

PLIB_SPI_InputSamplePhaseSelect
void PLIB_SPI_InputSamplePhaseSelect(SPI_MODULE_ID index, SPI_INPUT_SAMPLING_PHASE phase)

PLIB_USART_ReceiverByteReceive
int8_t PLIB_USART_ReceiverByteReceive(USART_MODULE_ID index)

PLIB_DMA_BusyActiveSet
void PLIB_DMA_BusyActiveSet(DMA_MODULE_ID index)

PLIB_DMA_ChannelXCollisionStatus
bool PLIB_DMA_ChannelXCollisionStatus(DMA_MODULE_ID index, DMA_CHANNEL channel, DMA_CHANNEL_COLLISION collisonType)

SYS_DMA_ChannelAbortEventSet
void SYS_DMA_ChannelAbortEventSet(SYS_DMA_CHANNEL_HANDLE handle, DMA_TRIGGER_SOURCE eventSrc)

PLIB_USART_ExistsBaudRateHigh
bool PLIB_USART_ExistsBaudRateHigh(USART_MODULE_ID index)

SYS_PORTS_OpenDrainDisable
void SYS_PORTS_OpenDrainDisable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_DATA_MASK mask)

PLIB_PORTS_PinDirectionOutputSet
void PLIB_PORTS_PinDirectionOutputSet(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

PLIB_PORTS_PinGetLatched
bool PLIB_PORTS_PinGetLatched(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

DRV_SPI_BufferAddWriteRead2
DRV_SPI_BUFFER_HANDLE DRV_SPI_BufferAddWriteRead2(DRV_HANDLE handle, void *txBuffer, size_t txSize, void *rxBuffer, size_t rxSize, DRV_SPI_BUFFER_EVENT_HANDLER completeCB, void *context, DRV_SPI_BUFFER_HANDLE *jobHandle)

APP_Tasks
void APP_Tasks(void)
Definition: app.c:130

DRV_TMR3_PeriodValueSet
void DRV_TMR3_PeriodValueSet(uint32_t value)

PLIB_DMA_ChannelXDisable
void PLIB_DMA_ChannelXDisable(DMA_MODULE_ID index, DMA_CHANNEL channel)

SYS_DMA_ChannelSourceTransferredSizeGet
size_t SYS_DMA_ChannelSourceTransferredSizeGet(SYS_DMA_CHANNEL_HANDLE handle)

PLIB_SPI_ExistsTransmitBufferFullStatus
bool PLIB_SPI_ExistsTransmitBufferFullStatus(SPI_MODULE_ID index)

DRV_TMR2_Stop
void DRV_TMR2_Stop(void)

PLIB_USART_ExistsReceiverFramingErrorStatus
bool PLIB_USART_ExistsReceiverFramingErrorStatus(USART_MODULE_ID index)

DRV_TMR_AlarmDisable
bool DRV_TMR_AlarmDisable(DRV_HANDLE handle)

PLIB_DMA_AbortTransferSet
void PLIB_DMA_AbortTransferSet(DMA_MODULE_ID index, DMA_CHANNEL channel)

DRV_TMR1_DividerRangeGet
DRV_TMR_OPERATION_MODE DRV_TMR1_DividerRangeGet(DRV_TMR_DIVIDER_RANGE *pDivRange)

DRV_TMR2_StopInIdleEnable
void DRV_TMR2_StopInIdleEnable(void)

PORTS_DATA_TYPE
uint32_t PORTS_DATA_TYPE
Definition: inszt_adc.c:18532

DRV_TMR3_Stop
void DRV_TMR3_Stop(void)

DRV_SPI_BufferAddWrite
DRV_SPI_BUFFER_HANDLE DRV_SPI_BufferAddWrite(DRV_HANDLE handle, void *txBuffer, size_t size, DRV_SPI_BUFFER_EVENT_HANDLER completeCB, void *context)

PLIB_DMA_ExistsChannelXCellProgressPointer
bool PLIB_DMA_ExistsChannelXCellProgressPointer(DMA_MODULE_ID index)

SYSTEM_OBJECTS::drvTmr1
SYS_MODULE_OBJ drvTmr1
Definition: inszt_adc.c:27661

DRV_USART_OPERATION_MODE
DRV_USART_OPERATION_MODE
Definition: inszt_adc.c:15059

SYSTEM_OBJECTS
Definition: inszt_adc.c:27656

DRV_USART_Status
SYS_STATUS DRV_USART_Status(SYS_MODULE_OBJ object)

PLIB_USART_TransmitterDisable
void PLIB_USART_TransmitterDisable(USART_MODULE_ID index)

DRV_USART_ERROR
DRV_USART_ERROR
Definition: inszt_adc.c:15426

SYS_DMA_CHANNEL_OPERATION_MODE_CRC::mode
SYS_DMA_CHANNEL_CRC_MODE mode
Definition: inszt_adc.c:13437

DRV_USART_ErrorGet
DRV_USART_ERROR DRV_USART_ErrorGet(const DRV_HANDLE client)

DRV_USART_LINE_CONTROL_8ODD1
Definition: inszt_adc.c:15335

DRV_TMR3_Status
static SYS_STATUS DRV_TMR3_Status(void)
Definition: inszt_adc.c:4043

_DRV_SPI_INIT::queueSize
uint8_t queueSize
Definition: inszt_adc.c:26592

PLIB_USART_ExistsStopInIdle
bool PLIB_USART_ExistsStopInIdle(USART_MODULE_ID index)

PLIB_SPI_AudioErrorEnable
void PLIB_SPI_AudioErrorEnable(SPI_MODULE_ID index, SPI_AUDIO_ERROR error)

DRV_USART_TransmitBufferSizeGet
unsigned int DRV_USART_TransmitBufferSizeGet(const DRV_HANDLE handle)

DRV_TMR0_OperationModeGet
static DRV_TMR_OPERATION_MODE DRV_TMR0_OperationModeGet(void)
Definition: inszt_adc.c:3735

SYS_PORTS_DIRECTION_INPUT
Definition: inszt_adc.c:21897

qqqshell_upload
int qqqshell_upload
Definition: inszt_main.c:150

DRV_TMR_PrescalerGet
TMR_PRESCALE DRV_TMR_PrescalerGet(DRV_HANDLE handle)

PLIB_SPI_ExistsAudioCommunicationWidth
bool PLIB_SPI_ExistsAudioCommunicationWidth(SPI_MODULE_ID index)

DRV_USART_BufferRemove
DRV_USART_BUFFER_RESULT DRV_USART_BufferRemove(DRV_USART_BUFFER_HANDLE bufferHandle)

QQQnumfil
#define QQQnumfil
Definition: inszt_adc.c:50

SYS_PORTS_PULLUP_PULLDOWN_STATUS
SYS_PORTS_PULLUP_PULLDOWN_STATUS
Definition: inszt_adc.c:21864

DRV_USART_INIT::interruptReceive
INT_SOURCE interruptReceive
Definition: inszt_adc.c:15575

DRV_USART_Read
size_t DRV_USART_Read(const DRV_HANDLE handle, void *buffer, const size_t numbytes)

PLIB_DMA_ChannelXEventIsDetected
bool PLIB_DMA_ChannelXEventIsDetected(DMA_MODULE_ID index, DMA_CHANNEL channel)

PLIB_SPI_BufferRead32bit
uint32_t PLIB_SPI_BufferRead32bit(SPI_MODULE_ID index)

_DRV_SPI_INIT::allowIdleRun
bool allowIdleRun
Definition: inszt_adc.c:26543

PLIB_DMA_ExistsCRCType
bool PLIB_DMA_ExistsCRCType(DMA_MODULE_ID index)

DRV_TMR2_Tasks
static void DRV_TMR2_Tasks(void)
Definition: inszt_adc.c:4005

PLIB_USART_ReceiverInterruptModeSelect
void PLIB_USART_ReceiverInterruptModeSelect(USART_MODULE_ID index, USART_RECEIVE_INTR_MODE interruptMode)

PLIB_USART_ExistsReceiverIdleStatus
bool PLIB_USART_ExistsReceiverIdleStatus(USART_MODULE_ID index)

PLIB_DMA_RecentAddressAccessed
uint32_t PLIB_DMA_RecentAddressAccessed(DMA_MODULE_ID index)

SYS_DMA_DATA_WIDTH
SYS_DMA_DATA_WIDTH
Definition: inszt_adc.c:13522

PLIB_PORTS_ChannelSlewRateSelect
void PLIB_PORTS_ChannelSlewRateSelect(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_DATA_MASK channelMask, PORTS_PIN_SLEW_RATE slewRate)

SYS_DEBUG_INIT::errorLevel
SYS_ERROR_LEVEL errorLevel
Definition: inszt_adc.c:17598

DRV_USART_INIT_FLAG_WAKE_ON_START
Definition: inszt_adc.c:15377

PLIB_PORTS_ExistsChangeNoticePerPortStatus
bool PLIB_PORTS_ExistsChangeNoticePerPortStatus(PORTS_MODULE_ID index)

DRV_TMR2_PeriodValueSet
void DRV_TMR2_PeriodValueSet(uint32_t value)

PLIB_DMA_ChannelXNullWriteModeEnable
void PLIB_DMA_ChannelXNullWriteModeEnable(DMA_MODULE_ID index, DMA_CHANNEL channel)

DRV_USART_BUFFER_RESULT_HANDLE_INVALID
Definition: inszt_adc.c:15122

DRV_USART_Initialize
SYS_MODULE_OBJ DRV_USART_Initialize(const SYS_MODULE_INDEX index, const SYS_MODULE_INIT *const init)

_DRV_SPI_CLIENT_DATA::operationEnded
DRV_SPI_BUFFER_EVENT_HANDLER operationEnded
Definition: inszt_adc.c:26642

PLIB_SPI_ExistsAudioErrorControl
bool PLIB_SPI_ExistsAudioErrorControl(SPI_MODULE_ID index)

DRV_USART_CLIENT_STATUS_BUSY
Definition: inszt_adc.c:15473

DRV_TMR0_Start
bool DRV_TMR0_Start(void)

DRV_USART_ERROR_FRAMING
Definition: inszt_adc.c:15440

DRV_TMR4_Close
static void DRV_TMR4_Close(void)
Definition: inszt_adc.c:4185

DRV_USART_INIT
Definition: inszt_adc.c:15525

DRV_TMR0_Open
static void DRV_TMR0_Open(void)
Definition: inszt_adc.c:3724

QQQfirstmcdc
static int QQQfirstmcdc
Definition: inszt_adc.c:75

SYS_DMA_DESCRIPTOR_CONTROL
Definition: inszt_adc.c:13539

PLIB_PORTS_ChangeNoticePerPortTurnOff
void PLIB_PORTS_ChangeNoticePerPortTurnOff(PORTS_MODULE_ID index, PORTS_CHANNEL channel)

_DRV_SPI_INIT::spiSlaveSSPin
bool spiSlaveSSPin
Definition: inszt_adc.c:26547

DRV_USART_INIT::dmaChannelReceive
DMA_CHANNEL dmaChannelReceive
Definition: inszt_adc.c:15597

DRV_TMR4_ClockSet
bool DRV_TMR4_ClockSet(DRV_TMR_CLK_SOURCES clockSource, TMR_PRESCALE prescale)

PLIB_DMA_ExistsCRCPolynomialLength
bool PLIB_DMA_ExistsCRCPolynomialLength(DMA_MODULE_ID index)

PLIB_DMA_Enable
void PLIB_DMA_Enable(DMA_MODULE_ID index)

PLIB_DMA_ChannelXPatternIgnoreSet
void PLIB_DMA_ChannelXPatternIgnoreSet(DMA_MODULE_ID index, DMA_CHANNEL channel, uint8_t pattern)

DRV_SPI_CLOCK_MODE_IDLE_LOW_EDGE_RISE
Definition: inszt_adc.c:26306

PLIB_USART_ExistsTransmitterIdleIsLow
bool PLIB_USART_ExistsTransmitterIdleIsLow(USART_MODULE_ID index)

DRV_TMR_ClockSet
bool DRV_TMR_ClockSet(DRV_HANDLE handle, DRV_TMR_CLK_SOURCES clockSource, TMR_PRESCALE preScale)

PLIB_USART_BaudRateHighEnable
void PLIB_USART_BaudRateHighEnable(USART_MODULE_ID index)

PLIB_DMA_CRCTypeSet
void PLIB_DMA_CRCTypeSet(DMA_MODULE_ID index, DMA_CRC_TYPE CRCType)

PLIB_PORTS_ChannelChangeNoticeEdgeDisable
void PLIB_PORTS_ChannelChangeNoticeEdgeDisable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_DATA_MASK edgeRisingMask, PORTS_DATA_MASK edgeFallingMask)

PLIB_PORTS_OpenDrainDisable
void PLIB_PORTS_OpenDrainDisable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_DATA_MASK mask)

PLIB_SPI_ExistsFrameErrorStatus
bool PLIB_SPI_ExistsFrameErrorStatus(SPI_MODULE_ID index)

DRV_TMR_INIT::mode
DRV_TMR_OPERATION_MODE mode
Definition: inszt_adc.c:1910

PLIB_USART_ExistsReceiverDataAvailableStatus
bool PLIB_USART_ExistsReceiverDataAvailableStatus(USART_MODULE_ID index)

PLIB_PORTS_PinModeSelect
void PLIB_PORTS_PinModeSelect(PORTS_MODULE_ID index, PORTS_ANALOG_PIN pin, PORTS_PIN_MODE mode)

PLIB_USART_ExistsTransmitter
bool PLIB_USART_ExistsTransmitter(USART_MODULE_ID index)

DRV_USART_BUFFER_EVENT
DRV_USART_BUFFER_EVENT
Definition: inszt_adc.c:15096

DRV_SPI_CLOCK_MODE
DRV_SPI_CLOCK_MODE
Definition: inszt_adc.c:26299

SYS_PORTS_InterruptEnable
void SYS_PORTS_InterruptEnable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos, PORTS_PIN_INTERRUPT_TYPE pinInterruptType)

DRV_TMR0_PrescalerGet
TMR_PRESCALE DRV_TMR0_PrescalerGet(void)

DRV_TMR1_ClientStatus
DRV_TMR_CLIENT_STATUS DRV_TMR1_ClientStatus(void)

PLIB_DMA_ChannelXStartAddressOffsetSet
void PLIB_DMA_ChannelXStartAddressOffsetSet(DMA_MODULE_ID index, DMA_CHANNEL channel, uint16_t address, DMA_ADDRESS_OFFSET_TYPE offset)

SYS_DMA_CHANNEL_CHAIN_PRIO
SYS_DMA_CHANNEL_CHAIN_PRIO
Definition: inszt_adc.c:13295

PLIB_USART_ReceiverAddressGet
void * PLIB_USART_ReceiverAddressGet(USART_MODULE_ID index)

SYS_PORTS_Toggle
void SYS_PORTS_Toggle(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_DATA_MASK toggleMask)

PLIB_DMA_ExistsSuspend
bool PLIB_DMA_ExistsSuspend(DMA_MODULE_ID index)

DRV_USART_BUFFER_RESULT_REMOVAL_FAILED
Definition: inszt_adc.c:15129

PLIB_DMA_ExistsChannelBits
bool PLIB_DMA_ExistsChannelBits(DMA_MODULE_ID index)

DRV_USART_HANDSHAKE_FLOWCONTROL
Definition: inszt_adc.c:15245

PLIB_SPI_BufferWrite16bit
void PLIB_SPI_BufferWrite16bit(SPI_MODULE_ID index, uint16_t data)

DRV_USART_TransferStatus
DRV_USART_TRANSFER_STATUS DRV_USART_TransferStatus(const DRV_HANDLE handle)

SYS_PORTS_ChangeNotificationInIdleModeEnable
void SYS_PORTS_ChangeNotificationInIdleModeEnable(PORTS_MODULE_ID index)

PLIB_DMA_ChannelXCellProgressPointerGet
uint16_t PLIB_DMA_ChannelXCellProgressPointerGet(DMA_MODULE_ID index, DMA_CHANNEL dmaChannel)

PLIB_PORTS_ExistsPortsWrite
bool PLIB_PORTS_ExistsPortsWrite(PORTS_MODULE_ID index)

PLIB_USART_TransmitterBufferIsFull
bool PLIB_USART_TransmitterBufferIsFull(USART_MODULE_ID index)

PLIB_USART_ExistsReceiverAddress
bool PLIB_USART_ExistsReceiverAddress(USART_MODULE_ID index)

DRV_USART_INIT_FLAGS
DRV_USART_INIT_FLAGS
Definition: inszt_adc.c:15364

DRV_USART_INIT::linesEnable
USART_OPERATION_MODE linesEnable
Definition: inszt_adc.c:15567

DRV_IO_BUFFER_TYPE_NONE
Definition: inszt_adc.c:1080

DRV_ADC_MODULE_ID
DRV_ADC_MODULE_ID
Definition: inszt_adc.c:1509

SYS_DMA_CRC_WRITE_ORDER
SYS_DMA_CRC_WRITE_ORDER
Definition: inszt_adc.c:13358

DRV_USART_ByteErrorCallbackSet
void DRV_USART_ByteErrorCallbackSet(const SYS_MODULE_INDEX index, const DRV_USART_BYTE_EVENT_HANDLER eventHandler)

SYS_DMA_ERROR_ADDRESS_ERROR
Definition: inszt_adc.c:13499

DRV_TMR3_CounterValueGet
uint32_t DRV_TMR3_CounterValueGet(void)

sysObj
SYSTEM_OBJECTS sysObj

PLIB_DMA_LastBusAccessIsRead
bool PLIB_DMA_LastBusAccessIsRead(DMA_MODULE_ID index)

PLIB_USART_BaudRateAutoDetectIsComplete
bool PLIB_USART_BaudRateAutoDetectIsComplete(USART_MODULE_ID index)

PLIB_USART_AddressSet
void PLIB_USART_AddressSet(USART_MODULE_ID index, uint8_t address)

PLIB_PORTS_ExistsPinMode
bool PLIB_PORTS_ExistsPinMode(PORTS_MODULE_ID index)

PLIB_DMA_ChannelXTransferDirectionGet
DMA_CHANNEL_TRANSFER_DIRECTION PLIB_DMA_ChannelXTransferDirectionGet(DMA_MODULE_ID index, DMA_CHANNEL channel)

DRV_USART_LINE_CONTROL_8EVEN1
Definition: inszt_adc.c:15327

DRV_TMR2_DividerRangeGet
DRV_TMR_OPERATION_MODE DRV_TMR2_DividerRangeGet(DRV_TMR_DIVIDER_RANGE *pDivRange)

SYS_DEBUG_ErrorLevelSet
void SYS_DEBUG_ErrorLevelSet(SYS_ERROR_LEVEL level)

SYS_DMA_CHANNEL_CRC_MODE_APPEND
Definition: inszt_adc.c:13345

PLIB_DMA_ChannelXINTSourceEnable
void PLIB_DMA_ChannelXINTSourceEnable(DMA_MODULE_ID index, DMA_CHANNEL dmaChannel, DMA_INT_TYPE dmaINTSource)

SYS_DMA_CHANNEL_OPERATION_MODE_CRC::polyLength
uint8_t polyLength
Definition: inszt_adc.c:13441

tbrun_mode
static int tbrun_mode
Definition: inszt_adc.c:96

DRV_TMR_Deinitialize
void DRV_TMR_Deinitialize(SYS_MODULE_OBJ object)

SYS_DMA_CHANNEL_CHAIN_PRIO_LOW
Definition: inszt_adc.c:13301

PLIB_DMA_CRCBitOrderSelect
void PLIB_DMA_CRCBitOrderSelect(DMA_MODULE_ID index, DMA_CRC_BIT_ORDER bitOrder)

DRV_TMR1_Stop
void DRV_TMR1_Stop(void)

PLIB_DMA_ExistsChannelXINTSourceFlag
bool PLIB_DMA_ExistsChannelXINTSourceFlag(DMA_MODULE_ID index)

SYS_PORTS_PinDirectionSelect
void SYS_PORTS_PinDirectionSelect(PORTS_MODULE_ID index, SYS_PORTS_PIN_DIRECTION pinDir, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

_DRV_SPI_INIT::inputSamplePhase
SPI_INPUT_SAMPLING_PHASE inputSamplePhase
Definition: inszt_adc.c:26578

PLIB_DMA_ExistsChannelXPatternLength
bool PLIB_DMA_ExistsChannelXPatternLength(DMA_MODULE_ID index)

DRV_ADC0_Open
void DRV_ADC0_Open(void)

SYS_DEBUG_Message
void SYS_DEBUG_Message(const char *message)

PLIB_USART_RunInOverflowIsEnabled
bool PLIB_USART_RunInOverflowIsEnabled(USART_MODULE_ID index)

PLIB_PORTS_ExistsChangeNoticeEdgeControl
bool PLIB_PORTS_ExistsChangeNoticeEdgeControl(PORTS_MODULE_ID index)

PLIB_DMA_CRCWriteByteOrderMaintain
void PLIB_DMA_CRCWriteByteOrderMaintain(DMA_MODULE_ID index)

_DRV_SPI_CLIENT_DATA::operationStarting
DRV_SPI_BUFFER_EVENT_HANDLER operationStarting
Definition: inszt_adc.c:26635

DRV_IC0_Capture32BitDataRead
uint32_t DRV_IC0_Capture32BitDataRead(void)

SYS_DEBUG_ErrorLevelGet
SYS_ERROR_LEVEL SYS_DEBUG_ErrorLevelGet(void)

PLIB_DMA_ChannelXSourceSizeSet
void PLIB_DMA_ChannelXSourceSizeSet(DMA_MODULE_ID index, DMA_CHANNEL dmaChannel, uint16_t sourceSize)

SYS_DMA_Initialize
SYS_MODULE_OBJ SYS_DMA_Initialize(const SYS_MODULE_INIT *const init)

qqqbitmapreset
static void qqqbitmapreset(qqnull_params)

SYS_ERROR_ERROR
Definition: inszt_adc.c:17554

_DRV_SPI_INIT
Definition: inszt_adc.c:26531

PLIB_USART_LineControlModeSelect
void PLIB_USART_LineControlModeSelect(USART_MODULE_ID index, USART_LINECONTROL_MODE dataFlowConfig)

SYS_PORTS_OpenDrainEnable
void SYS_PORTS_OpenDrainEnable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_DATA_MASK mask)

PLIB_DMA_ChannelXDestinationSizeSet
void PLIB_DMA_ChannelXDestinationSizeSet(DMA_MODULE_ID index, DMA_CHANNEL dmaChannel, uint16_t destinationSize)

DRV_TMR1_Close
static void DRV_TMR1_Close(void)
Definition: inszt_adc.c:3855

DRV_USART_WriteByte
void DRV_USART_WriteByte(const DRV_HANDLE handle, const uint8_t byte)

qqqzzglobflag
static unsigned char qqqzzglobflag
Definition: inszt_adc.c:166

PLIB_PORTS_ChannelChangeNoticePullUpEnable
void PLIB_PORTS_ChannelChangeNoticePullUpEnable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_DATA_MASK mask)

ADC_STATE_WAIT_FOR_TIMER
Definition: inszt_adc.c:236

PLIB_USART_ExistsLineControlMode
bool PLIB_USART_ExistsLineControlMode(USART_MODULE_ID index)

DRV_USART0_Open
DRV_HANDLE DRV_USART0_Open(const SYS_MODULE_INDEX index, const DRV_IO_INTENT ioIntent)

PLIB_DMA_ChannelXPeripheralAddressGet
uint16_t PLIB_DMA_ChannelXPeripheralAddressGet(DMA_MODULE_ID index, DMA_CHANNEL channel)

PLIB_PORTS_PinChangeNoticeEnable
void PLIB_PORTS_PinChangeNoticeEnable(PORTS_MODULE_ID index, PORTS_CHANGE_NOTICE_PIN pinNum)

PLIB_DMA_ChannelXSourceStartAddressSet
void PLIB_DMA_ChannelXSourceStartAddressSet(DMA_MODULE_ID index, DMA_CHANNEL dmaChannel, uint32_t sourceStartAddress)

DRV_TMR1_PeriodValueSet
void DRV_TMR1_PeriodValueSet(uint32_t value)

PLIB_PORTS_ExistsPinChangeNotice
bool PLIB_PORTS_ExistsPinChangeNotice(PORTS_MODULE_ID index)

DRV_SPI_Close
void DRV_SPI_Close(DRV_HANDLE handle)

PLIB_DMA_ExistsChannelXSourcePointer
bool PLIB_DMA_ExistsChannelXSourcePointer(DMA_MODULE_ID index)

DRV_TMR_INIT::moduleInit
SYS_MODULE_INIT moduleInit
Definition: inszt_adc.c:1896

qqbmsoutput
static void qqbmsoutput(FILEPOINT char *s, unsigned int i)
Definition: inszt_adc.c:28069

DRV_TMR1_StopInIdleEnable
void DRV_TMR1_StopInIdleEnable(void)

SYSTEM_OBJECTS::drvTmr0
SYS_MODULE_OBJ drvTmr0
Definition: inszt_adc.c:27660

DRV_USART_ERROR_NONE
Definition: inszt_adc.c:15430

DRV_TMR2_PeriodValueGet
uint32_t DRV_TMR2_PeriodValueGet(void)

PLIB_DMA_CRCAppendModeIsEnabled
bool PLIB_DMA_CRCAppendModeIsEnabled(DMA_MODULE_ID index)

ADC_STATE_INIT
Definition: inszt_adc.c:234

PLIB_SPI_FramedCommunicationEnable
void PLIB_SPI_FramedCommunicationEnable(SPI_MODULE_ID index)

PLIB_DMA_CRCAppendModeEnable
void PLIB_DMA_CRCAppendModeEnable(DMA_MODULE_ID index)

PLIB_SPI_ExistsPinControl
bool PLIB_SPI_ExistsPinControl(SPI_MODULE_ID index)

SYSTEM_OBJECTS::spiObjectIdx2
SYS_MODULE_OBJ spiObjectIdx2
Definition: inszt_adc.c:27672

PLIB_PORTS_ExistsRemapInput
bool PLIB_PORTS_ExistsRemapInput(PORTS_MODULE_ID index)

SYS_DMA_CHANNEL_OPERATION_MODE_CRC::xorBitMask
uint32_t xorBitMask
Definition: inszt_adc.c:13457

_DRV_SPI_INIT::audioTransmitMode
SPI_AUDIO_TRANSMIT_MODE audioTransmitMode
Definition: inszt_adc.c:26559

DRV_TMR_INIT
Definition: inszt_adc.c:1892

SYSTEM_OBJECTS::drvTmr3
SYS_MODULE_OBJ drvTmr3
Definition: inszt_adc.c:27663

PLIB_DMA_ChannelXINTSourceDisable
void PLIB_DMA_ChannelXINTSourceDisable(DMA_MODULE_ID index, DMA_CHANNEL dmaChannel, DMA_INT_TYPE dmaINTSource)

PLIB_PORTS_ExistsAnPinsMode
bool PLIB_PORTS_ExistsAnPinsMode(PORTS_MODULE_ID index)

DRV_USART_TasksTransmit
void DRV_USART_TasksTransmit(SYS_MODULE_OBJ object)

PLIB_DMA_ChannelXStartIRQSet
void PLIB_DMA_ChannelXStartIRQSet(DMA_MODULE_ID index, DMA_CHANNEL channel, DMA_TRIGGER_SOURCE IRQnum)

DRV_USART_OPERATION_MODE_ADDRESSED
Definition: inszt_adc.c:15075

PLIB_SPI_AudioTransmitModeSelect
void PLIB_SPI_AudioTransmitModeSelect(SPI_MODULE_ID index, SPI_AUDIO_TRANSMIT_MODE mode)

DRV_SPI_BUFFER_HANDLE
uintptr_t DRV_SPI_BUFFER_HANDLE
Definition: inszt_adc.c:26247

DRV_TMR_AlarmPeriodGet
uint32_t DRV_TMR_AlarmPeriodGet(DRV_HANDLE handle)

PLIB_DMA_ExistsChannelXAbortIRQ
bool PLIB_DMA_ExistsChannelXAbortIRQ(DMA_MODULE_ID index)

PLIB_SPI_FrameSyncPulsePolaritySelect
void PLIB_SPI_FrameSyncPulsePolaritySelect(SPI_MODULE_ID index, SPI_FRAME_PULSE_POLARITY polarity)

DRV_TMR_Start
bool DRV_TMR_Start(DRV_HANDLE handle)

PLIB_DMA_ExistsChannelXINTSource
bool PLIB_DMA_ExistsChannelXINTSource(DMA_MODULE_ID index)

PLIB_USART_ExistsRunInOverflow
bool PLIB_USART_ExistsRunInOverflow(USART_MODULE_ID index)

adc_63zqqzqz
static int adc_63zqqzqz(qqnull_params)
Definition: inszt_adc.c:27997

DRV_ADC_Stop
void DRV_ADC_Stop(void)

bitmapstruct_t
Definition: inszt_adc.c:167

DRV_TMR3_CounterClear
void DRV_TMR3_CounterClear(void)

DRV_TMR_AlarmHasElapsed
uint32_t DRV_TMR_AlarmHasElapsed(DRV_HANDLE handle)

PLIB_SPI_FrameSyncPulseWidthSelect
void PLIB_SPI_FrameSyncPulseWidthSelect(SPI_MODULE_ID index, SPI_FRAME_PULSE_WIDTH width)

DRV_USART_OPERATION_MODE_LOOPBACK
Definition: inszt_adc.c:15079

PLIB_DMA_ExistsChannelXSourceSize
bool PLIB_DMA_ExistsChannelXSourceSize(DMA_MODULE_ID index)

DRV_USART_Open
DRV_HANDLE DRV_USART_Open(const SYS_MODULE_INDEX index, const DRV_IO_INTENT ioIntent)

SYSTEM_OBJECTS::drvUSBObject
SYS_MODULE_OBJ drvUSBObject
Definition: inszt_adc.c:27673

SYS_DMA_TasksErrorISR
void SYS_DMA_TasksErrorISR(SYS_MODULE_OBJ object, DMA_CHANNEL activeChannel)

DRV_USART_LINE_CONTROL_SET_ERROR
Definition: inszt_adc.c:15291

APP_Initialize
void APP_Initialize(void)
Definition: app.c:93

_DRV_SPI_INIT::audioProtocolMode
SPI_AUDIO_PROTOCOL audioProtocolMode
Definition: inszt_adc.c:26561

PLIB_PORTS_CnPinsPullUpDisable
void PLIB_PORTS_CnPinsPullUpDisable(PORTS_MODULE_ID index, PORTS_CN_PIN cnPins)

DRV_IO_INTENT_READWRITE
Definition: inszt_adc.c:987

DRV_TMR3_DeInitialize
static void DRV_TMR3_DeInitialize(void)
Definition: inszt_adc.c:4034

_DRV_SPI_INIT::numTrfsSmPolled
uint8_t numTrfsSmPolled
Definition: inszt_adc.c:26587

SYS_DMA_ChannelTransferSet
void SYS_DMA_ChannelTransferSet(SYS_DMA_CHANNEL_HANDLE handle, const void *srcAddr, size_t srcSize, const void *destAddr, size_t destSize, size_t cellSize)

_DRV_SPI_INIT::clockMode
DRV_SPI_CLOCK_MODE clockMode
Definition: inszt_adc.c:26576

PLIB_PORTS_ChangeNoticePerPortHasOccurred
bool PLIB_PORTS_ChangeNoticePerPortHasOccurred(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

PLIB_SPI_BufferWrite32bit
void PLIB_SPI_BufferWrite32bit(SPI_MODULE_ID index, uint32_t data)

PLIB_PORTS_ExistsChangeNoticePullDownPerPort
bool PLIB_PORTS_ExistsChangeNoticePullDownPerPort(PORTS_MODULE_ID index)

SYS_PORTS_PinSet
void SYS_PORTS_PinSet(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

PLIB_USART_BaudRateHighSet
void PLIB_USART_BaudRateHighSet(USART_MODULE_ID index, uint32_t clockFrequency, uint32_t baudRate)

SYS_DMA_INIT
Definition: inszt_adc.c:13513

DRV_TMR3_OperationModeGet
static DRV_TMR_OPERATION_MODE DRV_TMR3_OperationModeGet(void)
Definition: inszt_adc.c:4065

SYS_PORTS_ChangeNotificationGlobalDisable
void SYS_PORTS_ChangeNotificationGlobalDisable(PORTS_MODULE_ID index)

qqupload_registered
int qqupload_registered
Definition: inszt_main.c:6760

PLIB_DMA_ChannelXINTSourceFlagGet
bool PLIB_DMA_ChannelXINTSourceFlagGet(DMA_MODULE_ID index, DMA_CHANNEL dmaChannel, DMA_INT_TYPE dmaINTSource)

PLIB_USART_ExistsBRGClockSourceSelect
bool PLIB_USART_ExistsBRGClockSourceSelect(USART_MODULE_ID index)

DRV_TMR0_DividerRangeGet
DRV_TMR_OPERATION_MODE DRV_TMR0_DividerRangeGet(DRV_TMR_DIVIDER_RANGE *pDivRange)

DRV_TMR2_CounterClear
void DRV_TMR2_CounterClear(void)

qqoutput
static void qqoutput(FILEPOINT char *s, int i)
Definition: inszt_adc.c:27910

PLIB_SPI_ExistsFramedCommunication
bool PLIB_SPI_ExistsFramedCommunication(SPI_MODULE_ID index)

PLIB_PORTS_ChangeNoticePullUpPerPortDisable
void PLIB_PORTS_ChangeNoticePullUpPerPortDisable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

DRV_USART_TransmitBufferIsFull
bool DRV_USART_TransmitBufferIsFull(const DRV_HANDLE handle)

PLIB_DMA_ChannelXBusyIsBusy
bool PLIB_DMA_ChannelXBusyIsBusy(DMA_MODULE_ID index, DMA_CHANNEL channel)

DRV_USART0_Initialize
SYS_MODULE_OBJ DRV_USART0_Initialize(void)

PLIB_PORTS_RemapOutput
void PLIB_PORTS_RemapOutput(PORTS_MODULE_ID index, PORTS_REMAP_OUTPUT_FUNCTION outputFunction, PORTS_REMAP_OUTPUT_PIN remapOutputPin)

adc_63zqzqzq
static int adc_63zqzqzq(int qqqi)
Definition: inszt_adc.c:28117

DRV_TMR_CounterValueGet
uint32_t DRV_TMR_CounterValueGet(DRV_HANDLE handle)

SYS_DMA_CHANNEL_HANDLE
uintptr_t SYS_DMA_CHANNEL_HANDLE
Definition: inszt_adc.c:13249

PLIB_DMA_ChannelXBusyInActiveSet
void PLIB_DMA_ChannelXBusyInActiveSet(DMA_MODULE_ID index, DMA_CHANNEL channel)

PLIB_USART_ExistsOperationMode
bool PLIB_USART_ExistsOperationMode(USART_MODULE_ID index)

SYS_DMA_ChannelCRCSet
void SYS_DMA_ChannelCRCSet(SYS_DMA_CHANNEL_HANDLE handle, SYS_DMA_CHANNEL_OPERATION_MODE_CRC crc)

DRV_USART_BufferAddRead
void DRV_USART_BufferAddRead(const DRV_HANDLE handle, DRV_USART_BUFFER_HANDLE *const bufferHandle, void *buffer, const size_t size)

DRV_USART_HANDSHAKE_SIMPLEX
Definition: inszt_adc.c:15249

PLIB_DMA_ChannelXPatternIgnoreByteEnable
void PLIB_DMA_ChannelXPatternIgnoreByteEnable(DMA_MODULE_ID index, DMA_CHANNEL channel)

PLIB_USART_Transmitter9BitsSend
void PLIB_USART_Transmitter9BitsSend(USART_MODULE_ID index, int8_t data, bool Bit9th)

DRV_SPI_Tasks
void DRV_SPI_Tasks(SYS_MODULE_OBJ object)

PLIB_DMA_CRCChannelSelect
void PLIB_DMA_CRCChannelSelect(DMA_MODULE_ID index, DMA_CHANNEL channel)

PLIB_DMA_ChannelXCellSizeGet
uint16_t PLIB_DMA_ChannelXCellSizeGet(DMA_MODULE_ID index, DMA_CHANNEL dmaChannel)

adc_63zqqzqz1
#define adc_63zqqzqz1
Definition: inszt_adc.c:78

SYS_PORTS_Clear
void SYS_PORTS_Clear(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_DATA_MASK clearMask)

DRV_TMR_DIVIDER_RANGE
Definition: inszt_adc.c:1871

SYS_DMA_ChannelEnable
void SYS_DMA_ChannelEnable(SYS_DMA_CHANNEL_HANDLE handle)

DRV_USART_Write
size_t DRV_USART_Write(const DRV_HANDLE handle, void *buffer, const size_t numbytes)

DRV_IC0_Capture16BitDataRead
uint16_t DRV_IC0_Capture16BitDataRead(void)

APP_DATA
Definition: app.h:59

qqqupload
static void qqqupload(qqnull_params)
Definition: inszt_adc.c:28094

DRV_IO_INTENT_SHARED
Definition: inszt_adc.c:1003

DRV_TMR_CLKSOURCE_LPRC_OSCILLATOR_SYNCHRONOUS
Definition: inszt_adc.c:1728

DRV_USART0_Status
SYS_STATUS DRV_USART0_Status(void)

DRV_USART_TRANSFER_STATUS_RECEIVER_DATA_PRESENT
Definition: inszt_adc.c:15493

PLIB_DMA_ChannelXDestinationAddressModeSelect
void PLIB_DMA_ChannelXDestinationAddressModeSelect(DMA_MODULE_ID index, DMA_CHANNEL channel, DMA_DESTINATION_ADDRESSING_MODE destinationAddressMode)

ADC_DATA
Definition: adc.h:78

SYS_PORTS_DirectionSelect
void SYS_PORTS_DirectionSelect(PORTS_MODULE_ID index, SYS_PORTS_PIN_DIRECTION pinDir, PORTS_CHANNEL channel, PORTS_DATA_MASK mask)

DRV_TMR_CLIENT_STATUS_RUNNING
Definition: inszt_adc.c:1820

PLIB_SPI_TransmitUnderRunStatusGet
bool PLIB_SPI_TransmitUnderRunStatusGet(SPI_MODULE_ID index)

PLIB_PORTS_CnPinsEnable
void PLIB_PORTS_CnPinsEnable(PORTS_MODULE_ID index, PORTS_CN_PIN cnPins)

DRV_USART_AddressedBufferAddWrite
void DRV_USART_AddressedBufferAddWrite(const DRV_HANDLE hClient, DRV_USART_BUFFER_HANDLE *bufferHandle, uint8_t address, void *source, size_t nWords)

SYS_DMA_INIT::sidl
SYS_DMA_SIDL sidl
Definition: inszt_adc.c:13517

PLIB_PORTS_ChangeNoticePullDownPerPortEnable
void PLIB_PORTS_ChangeNoticePullDownPerPortEnable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

DRV_USART_BUFFER_RESULT
DRV_USART_BUFFER_RESULT
Definition: inszt_adc.c:15118

DRV_IC0_Stop
void DRV_IC0_Stop(void)

DRV_TMR2_ClockSet
bool DRV_TMR2_ClockSet(DRV_TMR_CLK_SOURCES clockSource, TMR_PRESCALE prescale)

DRV_USART_ERROR_PARITY
Definition: inszt_adc.c:15435

PLIB_DMA_ChannelXChainIsEnabled
bool PLIB_DMA_ChannelXChainIsEnabled(DMA_MODULE_ID index, DMA_CHANNEL channel)

PLIB_SPI_AudioErrorDisable
void PLIB_SPI_AudioErrorDisable(SPI_MODULE_ID index, SPI_AUDIO_ERROR error)

DRV_TMR0_PeriodValueGet
uint32_t DRV_TMR0_PeriodValueGet(void)

PLIB_PORTS_ExistsChangeNoticePullUpPerPort
bool PLIB_PORTS_ExistsChangeNoticePullUpPerPort(PORTS_MODULE_ID index)

DRV_ADC_SamplesRead
uint32_t DRV_ADC_SamplesRead(uint8_t bufIndex)

DRV_TMR_CLIENT_STATUS_READY
Definition: inszt_adc.c:1815

DRV_TMR3_ClockSet
bool DRV_TMR3_ClockSet(DRV_TMR_CLK_SOURCES clockSource, TMR_PRESCALE prescale)

qqqaccumupload
ldra_void_function qqqaccumupload[QQQnumfil]
Definition: inszt_main.c:153

PLIB_DMA_ChannelXSourceStartAddressGet
uint32_t PLIB_DMA_ChannelXSourceStartAddressGet(DMA_MODULE_ID index, DMA_CHANNEL dmaChannel)

SYS_DEBUG_Print
void SYS_DEBUG_Print(const char *format,...)

_DRV_SPI_INIT::rxInterruptSource
INT_SOURCE rxInterruptSource
Definition: inszt_adc.c:26582

SYS_PORTS_PinLatchedGet
bool SYS_PORTS_PinLatchedGet(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

DRV_IC_Initialize
SYS_MODULE_OBJ DRV_IC_Initialize(const SYS_MODULE_INDEX index, const SYS_MODULE_INIT *const init)

PLIB_PORTS_ReadLatched
PORTS_DATA_TYPE PLIB_PORTS_ReadLatched(PORTS_MODULE_ID index, PORTS_CHANNEL channel)

SYS_PORTS_PinWrite
void SYS_PORTS_PinWrite(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos, bool value)

PORTS_PIN_INTERRUPT_TYPE
PORTS_PIN_INTERRUPT_TYPE
Definition: inszt_adc.c:21903

DRV_USART0_TasksTransmit
void DRV_USART0_TasksTransmit(void)

SYS_ERROR_WARNING
Definition: inszt_adc.c:17556

DRV_TMR0_CounterFrequencyGet
uint32_t DRV_TMR0_CounterFrequencyGet(void)

PLIB_SPI_StopInIdleEnable
void PLIB_SPI_StopInIdleEnable(SPI_MODULE_ID index)

PLIB_USART_ExistsTransmitterInterruptMode
bool PLIB_USART_ExistsTransmitterInterruptMode(USART_MODULE_ID index)

PLIB_SPI_BaudRateClockSelect
void PLIB_SPI_BaudRateClockSelect(SPI_MODULE_ID index, SPI_BAUD_RATE_CLOCK type)

PLIB_SPI_ExistsOutputDataPhase
bool PLIB_SPI_ExistsOutputDataPhase(SPI_MODULE_ID index)

PLIB_DMA_ExistsEnableControl
bool PLIB_DMA_ExistsEnableControl(DMA_MODULE_ID index)

PLIB_DMA_ChannelPriorityGet
DMA_CHANNEL_PRIORITY PLIB_DMA_ChannelPriorityGet(DMA_MODULE_ID index)

PLIB_USART_ExistsModuleBusyStatus
bool PLIB_USART_ExistsModuleBusyStatus(USART_MODULE_ID index)

PLIB_DMA_ChannelXBusyActiveSet
void PLIB_DMA_ChannelXBusyActiveSet(DMA_MODULE_ID index, DMA_CHANNEL channel)

PLIB_PORTS_Write
void PLIB_PORTS_Write(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_DATA_TYPE value)

PLIB_DMA_ExistsChannelXBusy
bool PLIB_DMA_ExistsChannelXBusy(DMA_MODULE_ID index)

PLIB_USART_TransmitterInterruptModeSelect
void PLIB_USART_TransmitterInterruptModeSelect(USART_MODULE_ID index, USART_TRANSMIT_INTR_MODE fifolevel)

DRV_TMR3_DividerRangeGet
DRV_TMR_OPERATION_MODE DRV_TMR3_DividerRangeGet(DRV_TMR_DIVIDER_RANGE *pDivRange)

PLIB_USART_ReceiverIsIdle
bool PLIB_USART_ReceiverIsIdle(USART_MODULE_ID index)

PLIB_PORTS_PinChangeNoticePerPortDisable
void PLIB_PORTS_PinChangeNoticePerPortDisable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

DRV_IC_Capture32BitDataRead
uint32_t DRV_IC_Capture32BitDataRead(DRV_HANDLE handle)

PLIB_DMA_BusyActiveReset
void PLIB_DMA_BusyActiveReset(DMA_MODULE_ID index)

_DRV_SPI_INIT::errInterruptSource
INT_SOURCE errInterruptSource
Definition: inszt_adc.c:26584

DRV_USART_BufferAddWrite
void DRV_USART_BufferAddWrite(const DRV_HANDLE handle, DRV_USART_BUFFER_HANDLE *bufferHandle, void *buffer, const size_t size)

DRV_TMR_CLK_SOURCES
DRV_TMR_CLK_SOURCES
Definition: inszt_adc.c:1694

PLIB_SPI_SlaveSelectEnable
void PLIB_SPI_SlaveSelectEnable(SPI_MODULE_ID index)

SYS_DEBUG_Initialize
SYS_MODULE_OBJ SYS_DEBUG_Initialize(const SYS_MODULE_INDEX index, const SYS_MODULE_INIT *const init)

qqqaccumreset
ldra_void_function qqqaccumreset[QQQnumfil]
Definition: inszt_main.c:154

DRV_USART_INIT::moduleInit
SYS_MODULE_INIT moduleInit
Definition: inszt_adc.c:15529

SYS_DMA_ChannelSetup
void SYS_DMA_ChannelSetup(SYS_DMA_CHANNEL_HANDLE handle, SYS_DMA_CHANNEL_OP_MODE modeEnable, DMA_TRIGGER_SOURCE eventSrc)

PLIB_PORTS_Read
PORTS_DATA_TYPE PLIB_PORTS_Read(PORTS_MODULE_ID index, PORTS_CHANNEL channel)

SYS_DEBUG_INIT::consoleIndex
SYS_MODULE_INDEX consoleIndex
Definition: inszt_adc.c:17600

DRV_USART_LINE_CONTROL_SET_SUCCESS
Definition: inszt_adc.c:15295

DRV_USART_OBJ
Definition: inszt_adc.c:18260

PLIB_USART_Enable
void PLIB_USART_Enable(USART_MODULE_ID index)

DRV_TMR4_Tasks
static void DRV_TMR4_Tasks(void)
Definition: inszt_adc.c:4225

DRV_USART_INIT::mode
DRV_USART_OPERATION_MODE mode
Definition: inszt_adc.c:15537

PLIB_DMA_ChannelXINTSourceIsEnabled
bool PLIB_DMA_ChannelXINTSourceIsEnabled(DMA_MODULE_ID index, DMA_CHANNEL dmaChannel, DMA_INT_TYPE dmaINTSource)

DRV_USART_INIT_FLAG_AUTO_BAUD
Definition: inszt_adc.c:15383

DRV_SPI_TASK_MODE_ISR
Definition: inszt_adc.c:26453

DRV_SPI_Status
SYS_STATUS DRV_SPI_Status(SYS_MODULE_OBJ object)

PLIB_DMA_ChannelXTransferCountSet
void PLIB_DMA_ChannelXTransferCountSet(DMA_MODULE_ID index, DMA_CHANNEL channel, uint16_t transferCount)

PLIB_DMA_ChannelXAutoDisable
void PLIB_DMA_ChannelXAutoDisable(DMA_MODULE_ID index, DMA_CHANNEL channel)

PLIB_USART_ReceiverDataIsAvailable
bool PLIB_USART_ReceiverDataIsAvailable(USART_MODULE_ID index)

DRV_USART_INIT::dmaChannelTransmit
DMA_CHANNEL dmaChannelTransmit
Definition: inszt_adc.c:15593

DRV_USART_BaudSet
DRV_USART_BAUD_SET_RESULT DRV_USART_BaudSet(const DRV_HANDLE client, uint32_t baud)

SYS_PORTS_ChangeNotificationPullUpEnable
void SYS_PORTS_ChangeNotificationPullUpEnable(PORTS_MODULE_ID index, PORTS_CHANGE_NOTICE_PIN pinNum)

DRV_TMR4_Stop
void DRV_TMR4_Stop(void)

SYS_DMA_CHANNEL_OPERATION_MODE_CRC::byteOrder
DMA_CRC_BYTE_ORDER byteOrder
Definition: inszt_adc.c:13447

SYSTEM_OBJECTS::usbDevObject0
SYS_MODULE_OBJ usbDevObject0
Definition: inszt_adc.c:27674

DRV_TMR0_Initialize
void DRV_TMR0_Initialize(void)

_DRV_SPI_INIT::spiMode
DRV_SPI_MODE spiMode
Definition: inszt_adc.c:26541

PLIB_USART_ExistsTransmitterEnable
bool PLIB_USART_ExistsTransmitterEnable(USART_MODULE_ID index)

PLIB_SPI_ExistsBaudRateClock
bool PLIB_SPI_ExistsBaudRateClock(SPI_MODULE_ID index)

qqqqbmselwidth
static int qqqqbmselwidth
Definition: inszt_adc.c:48

SYS_DMA_CRC_WRITE_ORDER_CHANGE
Definition: inszt_adc.c:13366

PLIB_SPI_Enable
void PLIB_SPI_Enable(SPI_MODULE_ID index)

DRV_SPI_Initialize
SYS_MODULE_OBJ DRV_SPI_Initialize(const SYS_MODULE_INDEX index, const SYS_MODULE_INIT *const init)

PLIB_DMA_ChannelXSourceSizeGet
uint16_t PLIB_DMA_ChannelXSourceSizeGet(DMA_MODULE_ID index, DMA_CHANNEL dmaChannel)

DRV_USART_INIT::interruptError
INT_SOURCE interruptError
Definition: inszt_adc.c:15579

DRV_USART_BUFFER_RESULT_HANDLE_EXPIRED
Definition: inszt_adc.c:15124

PLIB_DMA_ChannelXTransferCountGet
uint16_t PLIB_DMA_ChannelXTransferCountGet(DMA_MODULE_ID index, DMA_CHANNEL channel)

PLIB_DMA_ExistsChannelXStartIRQ
bool PLIB_DMA_ExistsChannelXStartIRQ(DMA_MODULE_ID index)

DRV_TMR1_Initialize
void DRV_TMR1_Initialize(void)

DRV_TMR_OperationModeGet
DRV_TMR_OPERATION_MODE DRV_TMR_OperationModeGet(DRV_HANDLE handle)

DRV_TMR0_CounterValueGet
uint32_t DRV_TMR0_CounterValueGet(void)

PLIB_DMA_ChannelXPatternIgnoreByteDisable
void PLIB_DMA_ChannelXPatternIgnoreByteDisable(DMA_MODULE_ID index, DMA_CHANNEL channel)

DRV_TMR3_CounterValueSet
void DRV_TMR3_CounterValueSet(uint32_t value)

DRV_USART_LineControlSet
DRV_USART_LINE_CONTROL_SET_RESULT DRV_USART_LineControlSet(const DRV_HANDLE client, const DRV_USART_LINE_CONTROL lineControl)

PLIB_DMA_ExistsChannelXAuto
bool PLIB_DMA_ExistsChannelXAuto(DMA_MODULE_ID index)

SYS_PORTS_PinOpenDrainEnable
void SYS_PORTS_PinOpenDrainEnable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

DRV_TMR1_Start
bool DRV_TMR1_Start(void)

PLIB_SPI_AudioProtocolEnable
void PLIB_SPI_AudioProtocolEnable(SPI_MODULE_ID index)

SYS_ERROR_INFO
Definition: inszt_adc.c:17558

PLIB_DMA_ChannelXPatternLengthSet
void PLIB_DMA_ChannelXPatternLengthSet(DMA_MODULE_ID index, DMA_CHANNEL dmaChannel, DMA_PATTERN_LENGTH patternLen)

SYS_ERROR_DEBUG
Definition: inszt_adc.c:17560

DRV_SPI_TASK_MODE_POLLED
Definition: inszt_adc.c:26448

DRV_SPIn_TransmitterBufferIsFull
bool DRV_SPIn_TransmitterBufferIsFull(void)

SYSTEM_OBJECTS::drvUsart0
SYS_MODULE_OBJ drvUsart0
Definition: inszt_adc.c:27665

SYS_DMA_TasksError
void SYS_DMA_TasksError(SYS_MODULE_OBJ object)

PLIB_USART_ReceiverDisable
void PLIB_USART_ReceiverDisable(USART_MODULE_ID index)

SYS_DMA_CRC_WRITE_ORDER_MAINTAIN
Definition: inszt_adc.c:13363

_DRV_SPI_INIT::taskMode
DRV_SPI_TASK_MODE taskMode
Definition: inszt_adc.c:26539

ADC_DATA::tick
bool tick
Definition: adc.h:90

qqqqone
static char qqqqone[]
Definition: inszt_adc.c:27847

DRV_TMR_CLIENT_STATUS_BUSY
Definition: inszt_adc.c:1810

PLIB_USART_ExistsRunInSleepMode
bool PLIB_USART_ExistsRunInSleepMode(USART_MODULE_ID index)

qqpopulate_array_fcn_ptrQQ
void qqpopulate_array_fcn_ptrQQ(int x, ldra_void_function y, ldra_void_function z)
Definition: inszt_main.c:157

PLIB_PORTS_ExistsPortsRead
bool PLIB_PORTS_ExistsPortsRead(PORTS_MODULE_ID index)

PLIB_DMA_CRCChannelGet
DMA_CHANNEL PLIB_DMA_CRCChannelGet(DMA_MODULE_ID index)

DRV_TMR_Open
DRV_HANDLE DRV_TMR_Open(const SYS_MODULE_INDEX index, const DRV_IO_INTENT intent)

PLIB_DMA_ChannelXNullWriteModeDisable
void PLIB_DMA_ChannelXNullWriteModeDisable(DMA_MODULE_ID index, DMA_CHANNEL channel)

PLIB_USART_TransmitterBreakSendIsComplete
bool PLIB_USART_TransmitterBreakSendIsComplete(USART_MODULE_ID index)

DRV_TMR_CLKSOURCE_SECONDARY_OSCILLATOR_ASYNCHRONOUS
Definition: inszt_adc.c:1722

PLIB_SPI_ExistsFrameSyncPulseCounter
bool PLIB_SPI_ExistsFrameSyncPulseCounter(SPI_MODULE_ID index)

qqqlast
static int qqqlast
Definition: inszt_adc.c:27851

PLIB_USART_ReceiverOverrunHasOccurred
bool PLIB_USART_ReceiverOverrunHasOccurred(USART_MODULE_ID index)

PLIB_PORTS_ExistsPinChangeNoticePerPort
bool PLIB_PORTS_ExistsPinChangeNoticePerPort(PORTS_MODULE_ID index)

PLIB_DMA_ExistsChannelXPatternIgnoreByte
bool PLIB_DMA_ExistsChannelXPatternIgnoreByte(DMA_MODULE_ID index)

SYS_PORTS_PinToggle
void SYS_PORTS_PinToggle(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

PLIB_SPI_ExistsReceiveFIFOStatus
bool PLIB_SPI_ExistsReceiveFIFOStatus(SPI_MODULE_ID index)

PLIB_DMA_ExistsChannelXPriority
bool PLIB_DMA_ExistsChannelXPriority(DMA_MODULE_ID index)

DRV_USART_ByteTransmitCallbackSet
void DRV_USART_ByteTransmitCallbackSet(const SYS_MODULE_INDEX index, const DRV_USART_BYTE_EVENT_HANDLER eventHandler)

DRV_TMR0_StopInIdleDisable
void DRV_TMR0_StopInIdleDisable(void)

PLIB_USART_ReceiverIdleStateLowEnable
void PLIB_USART_ReceiverIdleStateLowEnable(USART_MODULE_ID index)

DRV_TMR4_Open
static void DRV_TMR4_Open(void)
Definition: inszt_adc.c:4164

PLIB_DMA_ChannelXIsEnabled
bool PLIB_DMA_ChannelXIsEnabled(DMA_MODULE_ID index, DMA_CHANNEL channel)

PLIB_USART_InitializeModeGeneral
void PLIB_USART_InitializeModeGeneral(USART_MODULE_ID index, bool autobaud, bool loopBackMode, bool wakeFromSleep, bool irdaMode, bool stopInIdle)

PLIB_DMA_ChannelXDestinationStartAddressSet
void PLIB_DMA_ChannelXDestinationStartAddressSet(DMA_MODULE_ID index, DMA_CHANNEL dmaChannel, uint32_t destinationStartAddress)

PLIB_DMA_ChannelXTriggerSourceNumberGet
DMA_CHANNEL_INT_SOURCE PLIB_DMA_ChannelXTriggerSourceNumberGet(DMA_MODULE_ID index, DMA_CHANNEL channel)

DRV_TMR_CLKSOURCE_SECONDARY_OSCILLATOR_SYNCHRONOUS
Definition: inszt_adc.c:1716

PLIB_DMA_ExistsChannelXChain
bool PLIB_DMA_ExistsChannelXChain(DMA_MODULE_ID index)

PLIB_SPI_OutputDataPhaseSelect
void PLIB_SPI_OutputDataPhaseSelect(SPI_MODULE_ID index, SPI_OUTPUT_DATA_PHASE phase)

DRV_IC_Close
#define DRV_IC_Close(handle)
Definition: inszt_adc.c:1418

DRV_USART0_ReceiverBufferSizeGet
unsigned int DRV_USART0_ReceiverBufferSizeGet(void)

DRV_TMR1_OperationModeGet
static DRV_TMR_OPERATION_MODE DRV_TMR1_OperationModeGet(void)
Definition: inszt_adc.c:3845

DRV_TMR_CLKSOURCE_EXTERNAL_SYNCHRONOUS
Definition: inszt_adc.c:1704

SYS_PORTS_ChangeNotificationDisable
void SYS_PORTS_ChangeNotificationDisable(PORTS_MODULE_ID index, PORTS_CHANGE_NOTICE_PIN pinNum)

DRV_TMR4_CounterValueSet
void DRV_TMR4_CounterValueSet(uint32_t value)

SYS_DMA_ChannelResume
void SYS_DMA_ChannelResume(SYS_DMA_CHANNEL_HANDLE handle)

PLIB_DMA_ChannelXTransferDirectionSelect
void PLIB_DMA_ChannelXTransferDirectionSelect(DMA_MODULE_ID index, DMA_CHANNEL channel, DMA_CHANNEL_TRANSFER_DIRECTION chTransferDirection)

DRV_CLIENT_STATUS
DRV_CLIENT_STATUS
Definition: inszt_adc.c:1019

DRV_USART_OPERATION_MODE_IRDA
Definition: inszt_adc.c:15063

DRV_IO_INTENT_READ
Definition: inszt_adc.c:979

PLIB_USART_ExistsHandshakeMode
bool PLIB_USART_ExistsHandshakeMode(USART_MODULE_ID index)

SYS_PORTS_PinPullDownDisable
void SYS_PORTS_PinPullDownDisable(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

DRV_SPI_BufferAddRead2
DRV_SPI_BUFFER_HANDLE DRV_SPI_BufferAddRead2(DRV_HANDLE handle, void *rxBuffer, size_t size, DRV_SPI_BUFFER_EVENT_HANDLER completeCB, void *context, DRV_SPI_BUFFER_HANDLE *jobHandle)

_DRV_SPI_INIT::frameSyncPulse
SPI_FRAME_SYNC_PULSE frameSyncPulse
Definition: inszt_adc.c:26549

zzfileid
static int zzfileid
Definition: inszt_adc.c:49

DRV_USART_TRANSFER_STATUS_RECEIVER_EMPTY
Definition: inszt_adc.c:15498

DRV_TMR0_Stop
void DRV_TMR0_Stop(void)

DRV_SPI_BUFFER_TYPE_STANDARD
Definition: inszt_adc.c:26348

PLIB_PORTS_PinChangeNoticeEdgeIsEnabled
bool PLIB_PORTS_PinChangeNoticeEdgeIsEnabled(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos, PORTS_CHANGE_NOTICE_EDGE cnEdgeType)

PLIB_USART_TransmitterIdleIsLowEnable
void PLIB_USART_TransmitterIdleIsLowEnable(USART_MODULE_ID index)

SYS_PORTS_DIRECTION_OUTPUT
Definition: inszt_adc.c:21892

PLIB_DMA_ExistsCRCChannel
bool PLIB_DMA_ExistsCRCChannel(DMA_MODULE_ID index)

DRV_PMP0_Read
uint8_t DRV_PMP0_Read(void)

SYS_DMA_TRANSFER_EVENT_COMPLETE
Definition: inszt_adc.c:13473

SYS_DMA_CHANNEL_CRC_MODE_BACKGROUND
Definition: inszt_adc.c:13341

PLIB_DMA_ChannelXOperatingTransferModeSelect
void PLIB_DMA_ChannelXOperatingTransferModeSelect(DMA_MODULE_ID index, DMA_CHANNEL channel, DMA_TRANSFER_MODE channeltransferMode)

DRV_SPI_BUFFER_EVENT_PROCESSING
Definition: inszt_adc.c:26405

PLIB_USART_ExistsReceiverAddressMask
bool PLIB_USART_ExistsReceiverAddressMask(USART_MODULE_ID index)

PLIB_USART_BaudRateGet
uint32_t PLIB_USART_BaudRateGet(USART_MODULE_ID index, int32_t clockFrequency)

PLIB_DMA_ExistsChannelXSourceStartAddress
bool PLIB_DMA_ExistsChannelXSourceStartAddress(DMA_MODULE_ID index)

DRV_TMR2_Open
static void DRV_TMR2_Open(void)
Definition: inszt_adc.c:3944

DRV_TMR1_CounterFrequencyGet
uint32_t DRV_TMR1_CounterFrequencyGet(void)

DRV_IO_BUFFER_TYPE_READ
Definition: inszt_adc.c:1082

SYS_DMA_TRANSFER_EVENT
SYS_DMA_TRANSFER_EVENT
Definition: inszt_adc.c:13469

DRV_TMR1_PrescalerGet
TMR_PRESCALE DRV_TMR1_PrescalerGet(void)

PLIB_DMA_ChannelXChainToLower
void PLIB_DMA_ChannelXChainToLower(DMA_MODULE_ID index, DMA_CHANNEL channel)

DRV_USART_BUFFER_RESULT_REMOVED_SUCCESFULLY
Definition: inszt_adc.c:15126

DRV_CLIENT_STATUS_ERROR
Definition: inszt_adc.c:1025

PLIB_DMA_ExistsChannelXDestinationStartAddress
bool PLIB_DMA_ExistsChannelXDestinationStartAddress(DMA_MODULE_ID index)

DRV_TMR4_DeInitialize
static void DRV_TMR4_DeInitialize(void)
Definition: inszt_adc.c:4144

PLIB_USART_InitializeOperation
void PLIB_USART_InitializeOperation(USART_MODULE_ID index, USART_RECEIVE_INTR_MODE receiveInterruptMode, USART_TRANSMIT_INTR_MODE transmitInterruptMode, USART_OPERATION_MODE operationMode)

DRV_SPI_BUFFER_EVENT_PENDING
Definition: inszt_adc.c:26403

PLIB_SPI_BufferAddressGet
void * PLIB_SPI_BufferAddressGet(SPI_MODULE_ID index)

SYS_PORTS_PinClear
void SYS_PORTS_PinClear(PORTS_MODULE_ID index, PORTS_CHANNEL channel, PORTS_BIT_POS bitPos)

DRV_ADC1_Open
void DRV_ADC1_Open(void)

SYS_DMA_IsBusy
bool SYS_DMA_IsBusy(void)

PLIB_SPI_ExistsFrameSyncPulseEdge
bool PLIB_SPI_ExistsFrameSyncPulseEdge(SPI_MODULE_ID index)

DRV_TMR4_Start
bool DRV_TMR4_Start(void)

SYS_DMA_ChannelRelease
void SYS_DMA_ChannelRelease(SYS_DMA_CHANNEL_HANDLE handle)

FILEPOINT
#define FILEPOINT
Definition: inszt_adc.c:91

PLIB_USART_ReceiverOverrunErrorClear
void PLIB_USART_ReceiverOverrunErrorClear(USART_MODULE_ID index)

PLIB_DMA_ChannelXReloadDisable
void PLIB_DMA_ChannelXReloadDisable(DMA_MODULE_ID index, DMA_CHANNEL channel)

SYS_DEBUG_Reinitialize
void SYS_DEBUG_Reinitialize(SYS_MODULE_OBJ object, const SYS_MODULE_INIT *const init)

PLIB_USART_ExistsReceiverAddressAutoDetect
bool PLIB_USART_ExistsReceiverAddressAutoDetect(USART_MODULE_ID index)

SYS_PORTS_RemapOutput
void SYS_PORTS_RemapOutput(PORTS_MODULE_ID index, PORTS_REMAP_OUTPUT_FUNCTION function, PORTS_REMAP_OUTPUT_PIN remapPin)

PLIB_SPI_FIFOShiftRegisterIsEmpty
bool PLIB_SPI_FIFOShiftRegisterIsEmpty(SPI_MODULE_ID index)